# ryle

> A hierarchical state machine

Latest version **0.1.1** (published 2016-12-19) · MIT license · 0 weekly downloads

## Install

```sh
npm install ryle
pnpm add ryle
yarn add ryle
bun add ryle
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.1.1 |
| Published | 2016-12-19 |
| First published | 2016-12-19 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 0 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 0 |
| Author | Euan Smith |
| Maintainers | zakalwe314 |
| Keywords | fsm |

## Links

- npm: https://www.npmjs.com/package/ryle
- Repository: https://github.com/zakalwe314/ryle
- Homepage: https://github.com/zakalwe314/ryle#readme
- Issues: https://github.com/zakalwe314/ryle/issues
- npm.io page: https://npm.io/package/ryle

## Recent versions

- 0.1.1 (latest) — 2016-12-19
- 0.1.0 — 2016-12-19

## README

Ryle
====
A full hierarchical Finite State Machine (fsm).

##What?  Another state machine library?
Yes, I know, there are a lot.  This has a lot of the features of the others, plus a few more (I think):
- Understands, and is built on, promises.
- Can be used with any event, pubsub or signal libraries
- Properly hierarchical with all standard UML model state transitions supported
  - Nested state transitions fire exit and enter methods through the full path in order
  - A state can transition to itself and a parent state can define persistent transitions to sub-states.
- Reusable and composable
  - A state machine is defined once and then many instances of it can be run.
  - An existing state machine can be nested within another.
  - Abstract states can be defined which are then instantiated by a parent machine.

Above all I found many of the other fsm libraries required machine definition code which was not easy to read.
The easier code is to read then in general it is simpler to maintain and for others to follow.  I've tried to make resultant state definition code to be as readable as possible.

##Why Ryle?
I wanted to base the name on the phrase ['Ghost in the Machine'](https://en.wikipedia.org/wiki/Ghost_in_the_machine) which originated from the book ['The Concept of Mind'](https://en.wikipedia.org/wiki/The_Concept_of_Mind) by Gilbert Ryle, a British Philosopher.
   Ghost was already taken.
## Installation
  npm install ryle --save

##Usage

A very brief example which is also contained in `example.js`.  More documentation will follow to cover all the features listed above.
  
```
var ryle=require('ryle');

//define a state machine
var countdown=ryle({

  //the start must be a getter function returning the initial state
  get _start(){return this.tick},

  //this is the main state.  It transitions to itself every second and to done when complete
  tick: function(context){
    console.log(context.value);
    return ryle
      .on(!context.value,this.done)
      .onTimeout(1000, this.tick)
      .onExit(function(){--context.value});
  },
  done: function(){
    return ryle.exit();
  }
});

//Now to use the state machine
countdown(10).then(function(){console.log('Boom!')}); 
```  
 
## Tests
 
```
   npm test
```
## Contributing
 In lieu of a formal styleguide, take care to maintain the existing coding style.
 Add unit tests for any new or changed functionality. Lint and test your code.

## Notes
I'm refactoring this from code I use for our production web-app.  So far it has been added as-is and is fully functional, but needs a little TLC to make it more maintainable.


## Release History
- 0.1.0 Initial release

---
_Source: https://npm.io/package/ryle · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._