PHPackages                             simon-downes/spf-support - 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. [Framework](/categories/framework)
4. /
5. simon-downes/spf-support

ActiveLibrary[Framework](/categories/framework)

simon-downes/spf-support
========================

Support library of SPF - Simon's PHP Framework

010PHP

Since Jul 23Pushed 7y agoCompare

[ Source](https://github.com/simon-downes/spf-support)[ Packagist](https://packagist.org/packages/simon-downes/spf-support)[ RSS](/packages/simon-downes-spf-support/feed)WikiDiscussions master Synced 2d ago

READMEChangelogDependenciesVersions (1)Used By (0)

SPF Support
===========

[](#spf-support)

Provides various supporting elements to SPF, such as:

- Collections
- Configuration
- Fieldsets and Fields
- Twig Extension
- Validation

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

[](#requirements)

This library requires only PHP 7.2 or later and the SPF Contracts package (`simon-downes/spf-contracts`).

Installation
------------

[](#installation)

It is installable and autoloadable via Composer as `simon-downes/spf-support`.

Alternatively, download a release or clone this repository, and add the `\spf\support` namespace to an autoloader.

License
-------

[](#license)

SPF Support is open-sourced software licensed under the MIT license.

Collections
-----------

[](#collections)

This package provides basic implementation of the `Collection`, `Dictionary` and `Set` interfaces defined in the `spf-contracts` package.

`BaseCollection` accepts an array of items in its constructor and provides basic collection operations such as iteration, counting, emptying and testing for existence. There is no support for adding or removing individual items, this being provided by specific subclasses.

`BaseDictionary` extends `BaseCollection` to add support for adding and removing key/value pairs - each key being unique.

`BaseSet` extends `BaseCollection` to add support for adding and removing unique items.

```
use spf\support\collections\{BaseCollection, BaseDictionary, BaseSet};

$c = new BaseCollection([123, 456, 789]);

$c->count();		// returns 3
$c->contains(456);	// returns true
$c->contains(234);	// returns false
$c->isEmpty();		// returns false
$c->clear();		// remove all items
$c->isEmpty();		// returns true

$d = new BaseDictionary();

$d->add('foo', 123);
$d->add('bar', 456);
$d->has('foo');		// returns true
$d->has('baz');		// returns false
$d->get('foo');		// returns 123
$d->keys();			// returns ['foo', 'bar']
$d->remove('bar');

$d = new BaseSet();

$d->add('foo');
$d->add('bar');
$d->contains('foo');	// returns true
$d->remove('bar');
$d->contains('bar');	// returns false
```

Configuration
-------------

[](#configuration)

`BaseConfig` provides a basic configuration object, the underlying implementation being an array. The array can be populated from an external file via `load()`, or from an existing array via `merge()`. Methods are also provided to allow easy access to nested elements.

```
use spf\support\BaseConfig;

$c = new BaseConfig([
	'foo' => [
		'bar' => 123,
		'baz' => 456,
	],
]);

$c->get('foo.bar');	// returns 123

$c->set('foo.baz', 789);	// changes the value of ['foo']['bar']

// overwrite the 'foo' branch and add an additional value for 'bar'
$c->merge([
	'foo' => 'abc',
	'bar' => 'def',
]);

$c->get('foo.bar');	// returns null (key doesn't exist)

$c->get('bar');	// returns 'def'

$c->load(__DIR__. 'config.php');	// 'config.php' should return an array
```

Fieldsets and Fields
--------------------

[](#fieldsets-and-fields)

A field represents an object property, database column or similar construct.

Fieldsets are collections of Fields and can be used as database table/model definitions, html form definitions, etc.

### Fields

[](#fields)

A Field must have a name and a type and may optionally have additional rules defining rules for values that are considered valid.

Supported field types are listed in `spf\contracts\support\Type`.

```
use spf\support\Field;

$f = new Field('id', Type::INTEGER);
$f = new Field('email', Type::EMAIL, ['required' => true, 'unique' => true]);
$f = new Field(
	'status',
	Type::ENUM,
	[
		'required' => true,
		'values' => ['EMPLOYEE', 'PARTNER', 'OTHER']
	]
);
```

Available Rules:

- `required` - \[`boolean`\] if true, must have a non-empty value (default: false)
- `nullable` - \[`boolean`\] determines if null is an acceptable value (default: false)
- `default` - \[`mixed`\] default value to use if none specified (default: empty based on type)
- `label` - \[`string`\] user-friendly label, (default: title-cased name)
- `unique` - \[`boolean`\] determines if values should be unique (default: false)
- `min` - \[`integer|string`\] minimum acceptable value
- `max` - \[`integer|string`\] maximum acceptable value
- `min-length` - \[`integer`\] minimum length of value
- `max-length` - \[`integer`\] maximum length of value
- `regex` - \[`string`\] a regular expression that acceptable values must match
- `values` - \[`array`\] an array containing all acceptable values

Specified rules are available as properties on a Field object; e.g. `$f->required`. Fields are immutable once instantiated.

There are two methods provided for validation:

- `cast()` - cast a specified value to the Field's type
- `validate()` - validate a specified value against the Field's rules and return a 'cleaned' value and any validation error encountered. Supported errors are defined in `spf\contracts\support\Error`.

```
use spf\contracts\support\Error;
use spf\support\Field;

$f = new Field('id', Type::INTEGER, ['required' => true, 'min' => 0]);

$f->cast(false);		// returns 0
$f->cast('123fgh');		// returns 123
$f->cast('fghsdfs');	// returns 0

$f->validate(0);			// returns [0, Error::REQUIRED]
$f->validate(false);		// returns [false, Error::REQUIRED]
$f->validate('123fgh');		// returns [123, Error::NONE]
$f->validate('fghsdfs');	// returns ['fghsdfs', Error::TYPE]
$f->validate(-123);			// returns [-123, Error::MIN]
```

### Fieldsets

[](#fieldsets)

Fields are added via the `add()` method:

```
use spf\support\Fieldset;

$f = new Fieldset();
$f->add($name, $type = Type::TEXT, $rules = []);
```

All Fields in the Fieldset can be validated at once by calling the `validate()` method and passing an array of field names and values. The return value is an array containing two elements, the first is an array of 'cleaned' values, indexed by Field name; the second is an array of validation errors, indexed by Field name.

```
use spf\contracts\support\Error;
use spf\support\Fieldset;

$f = new Fieldset();

$f->add('id', Type::INTEGER);
$f->add('email', Type::EMAIL, ['required' => true, 'unique' => true]);

$f->validate([
	'id'    => '123',
	'email' => 'bar',
]);
/*
returns:
[
	[
		'id'    => 123,
		'email' => 'bar',
],
	[
		'id'    => Error::NONE,
		'email' => Error::EMAIL,
	],
]
```

Twig Extension
--------------

[](#twig-extension)

The Twig extension provides additional utility functionality to Twig environments.

### Tests (is):

[](#tests-is)

- `numeric` - determines if a variable contains a numeric value
- `integer` - determines if a variable contains an integer value
- `string` - determines if a variable is a string
- `array` - determines if a variable is an array
- `object` - determines if a variable is an object

### Filters

[](#filters)

- `md5` - generate the md5 hash of a value
- `sha1` - generate the sha1 hash of a value
- `truncate` - truncate a value to a specified length
- `sum` - generate the sum of an array, via `array_sum()`
- `shuffle` - shuffle an array, via `shuffle()`

### Functions

[](#functions)

- `ceil` - round a value up to next highest integer, via `ceil()`
- `floor` - round a value down to next lowest integer, via `floor()`

If the `spf-core` package is detected, most Helper methods are included as filters or functions where there is no corresponding native functionality.

Validation
----------

[](#validation)

The `spf\support\Validator` class contains static methods for validating values. Where possible validation is performed using PHP's built-in `filter_var()` function with appropriate flags. Validation function will return a valid value of the correct type, or an empty value of the correct type.

- `isEmpty($v, $type = Type::TEXT)`
- `validateText($v)`
- `validateInteger($v)`
- `validateFloat($v)`
- `validateBoolean($v)`
- `validateTimestamp($v)`
- `validateDateTime($v, $format = 'Y-m-d H:i:s')`
- `validateDate($v)`
- `validateTime($v)`
- `validateYear($v, $min = 1900, $max = 2155)`
- `validateEmail($v)`
- `validateIP($v)`
- `validateURL($v)`
- `validateJSON($v)`
- `validateObject($v, $class, $nullable = false)`

###  Health Score

19

—

LowBetter than 10% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity5

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity40

Maturing project, gaining track record

 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.

### Community

Maintainers

![](https://www.gravatar.com/avatar/ed0f7e8dc7c113e752674163bb779ca54730aa1533f9444d00f88940b52916a8?d=identicon)[simon-downes](/maintainers/simon-downes)

---

Top Contributors

[![simon-downes](https://avatars.githubusercontent.com/u/1052903?v=4)](https://github.com/simon-downes "simon-downes (1 commits)")

### Embed Badge

![Health badge](/badges/simon-downes-spf-support/health.svg)

```
[![Health](https://phpackages.com/badges/simon-downes-spf-support/health.svg)](https://phpackages.com/packages/simon-downes-spf-support)
```

###  Alternatives

[laravel/telescope

An elegant debug assistant for the Laravel framework.

5.2k67.8M192](/packages/laravel-telescope)[spiral/roadrunner

RoadRunner: High-performance PHP application server and process manager written in Go and powered with plugins

8.4k12.2M84](/packages/spiral-roadrunner)[nolimits4web/swiper

Most modern mobile touch slider and framework with hardware accelerated transitions

41.8k177.2k1](/packages/nolimits4web-swiper)[laravel/dusk

Laravel Dusk provides simple end-to-end testing and browser automation.

1.9k36.7M259](/packages/laravel-dusk)[laravel/prompts

Add beautiful and user-friendly forms to your command-line applications.

708181.8M596](/packages/laravel-prompts)[cakephp/chronos

A simple API extension for DateTime.

1.4k47.7M121](/packages/cakephp-chronos)

PHPackages © 2026

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