Download the PHP package uuf6429/state-engine without Composer
On this page you can find all versions of the php package uuf6429/state-engine. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.
Download uuf6429/state-engine
More information about uuf6429/state-engine
Files in uuf6429/state-engine
Package state-engine
Short Description A library providing interfaces and basic implementation of a State Engine or Machine
License MIT
Homepage https://github.com/uuf6429/state-engine-php
Informations about the package state-engine
🚦 State Engine / Machine (PHP)
This library provides some interfaces and a basic implementation of a State Engine or State Machine.
✨ Highlights:
- Dual functionality:
- Either as a basic state engine; switching to a desired state as long the transition is defined (see "JiraIssueTest")
- Or a more sophisticated state machine; same as above but matching data for any state (see "TurnstileTest")
- Highly composable - everything can be replaced as desired
- PSR-14 (Event Dispatcher) compatible
- Fluent builder interface (see "From Scratch")
- Generates Mermaid or PlantUML markup (see "Examples & Testing")
🔌 Installation
The recommended and easiest way to install this library is through Composer:
🧐 Why?
In principle such an engine is easy to implement, but in practice it is typically implemented badly or forgotten.
For instance, one might have an is_active field thinking there will not be other states and then later on an
is_pending field is needed, at which point refactoring flags to state is too late.
In any case, this library abstracts away that situation or at least decreases the amount of code.
🤔 How?
There are a few key parts to how this works:
- State - an object representing a single state of a model. So models may have different state levels, for example a door can have open and closed states, but it can also be locked and unlocked. In such a case, either consider the door lock as a separate model (with a separate engine instance) or merge all the states: open, closed-unlocked and closed-locked.
- Transition - an object representing a transition from one state to another. This is how you define the various state flows that your model can go through.
- TransitionRepository - an object that is aware of and provides all possible allowed transitions.
- Engine - an object that performs the transition of a model from one state to another. Usually you would have an engine instance for each stateful model in your application.
🚀 Usage
You have the possibility to use it from scratch or plug it into your existing. There are basically three parts to it:
- configuring the engine (creating states and transitions)
- using the engine (eg, in a web controller or service)
- (optionally) handling events (with the same event dispatcher provided to the engine)
A slightly different situation would be when you need to provide a list of valid transitions, for example to the user.
In this case, having the
StateTraversion
trait on the repository would be useful.
From Scratch
Here's a quick & dirty example with the provided implementation (that assumes that there is a "door" model):
From Scratch (Custom)
You don't like how the Engine works? Or you feel that State could have more details?
Then you're in luck! With the whole library based on interfaces, you can easily replace parts of the implementation.
For example, you could store states or transitions in a database, in which case you can have your own
TransitionRepository that accesses the database.
Existing Code
The library provides some flexibility so that you can connect your existing code with it. In more complicated scenarios, you may have to build a small layer to bridge the gap. The example below illustrates how one can handle models with flags instead of a single state.
😎 Examples & Testing
You can find some examples in this readme as well as the tests, some of which are explained below.
JiraIssueTest State Engine
This test provides a realistic example of how Jira Issue states could be set up.
The test also generates the Mermaid diagram below, thanks to the Mermaidable trait:
TurnstileTest State Machine
This test illustrates how a state machine can be used to model a turnstile gate. As before, here's the generated diagram:
Here's how the state machine definition looks like and how it could be used: