guseyn / cutie

Cutie is a lightweight library that implements Async Tree Pattern.

Cutie is a lightweight library that implements Async Tree Pattern.

Motivation

Let's say we want to read content from a file and write it to another one. And all these operations are asynchronous, of course. So, instead of writing something like this:

fs.readFile('./../file1.txt', 'utf8', (err, result) => {
  if (err != null) {
    throw err
  }
 
  fs.writeFile('./../file2.txt', result, (err) => {
    if (err != null) {
      throw err
    }
  })
})

we can design our code in the following style:

new WrittenFile(
  './../file2.txt',
  new ReadDataByPath('./../file1.txt', 'utf8')
).call()

How to use

You can use Cutie as a dependency via npm: npm install @cuties/cutie

const AsyncObject = require('@cuties/cutie').AsyncObject
const fs = require('fs')

// Represents file as path
class WrittenFile extends AsyncObject {
  constructor (path, content) {
    super(path, content)
  }
  
  asyncCall () {
    return (path, content, callback) => {
      this.path = path
      fs.writeFile(path, content, callback)
    }
  }

  onResult() {
    return this.path
  }
}

const AsyncObject = require('@cuties/cutie').AsyncObject
const fs = require('fs')

// Represents buffer or string
class ReadDataByPath extends AsyncObject {
  constructor (path, encoding) {
    super(path, encoding);
  }
  
  asyncCall () {
    return fs.readFile
  }
}

AsyncObject also provides methods OnResult and OnError, so that you can process the result (it's provided by callback by default) from async call and handle an error in the specific way (error is being thrown by default).

Let's say we want to read a json file and parse all information from there. Cutie provides two ways. First of them is just to create ParsedJSON async object like this:

const AsyncObject = require('@cuties/cutie').AsyncObject;
const fs = require('fs');

class ParsedJSON extends AsyncObject {
  constructor (path, encoding) {
    super(path, encoding)
  }
  
  asyncCall () {
    return fs.readFile
  }
  
  onResult (result) {
    return JSON.parse(result)
  }
}

// usage
new ParsedJSON('./../file.txt', 'utf8').call()

ParsedJSON also could be designed like this:

const fs = require('fs')
const ReadDataByPath = require('./ReadDataByPath')

class ParsedJSON extends ReadDataByPath {
  constructor (path, encoding) {
    super(path, encoding)
  }
  
  onResult (result) {
    return JSON.parse(result)
  }
}

// usage
new ParsedJSON('./../file.txt', 'utf8').call();

Or you can use ReadDataByPath with ParsedJSON that looks like this:

const AsyncObject = require('@cuties/cutie').AsyncObject
const fs = require('fs')
const ReadDataByPath = require('./ReadDataByPath')

class ParsedJSON extends AsyncObject {
  constructor (text) {
    super(text)
  }
  
  /*
    you can't call here async operations with I/O
  */
  syncCall () {
    return JSON.parse
  }
}

// usage
new ParsedJSON(
  new ReadDataByPath('./../file.txt', 'utf8')
).call()

Read more

1. Async Tree Pattern
2. Async Objects instead of Async Calls

Run test

npm test

Run build

npm run build

Libraries that use cutie

node-test-executor, cutie-is, cutie-assert, cutie-fs, cutie-http, cutie-https, cutie-rest, cutie-buffer, cutie-error, cutie-date, cutie-json, cutie-event, cutie-stream, cutie-object, cutie-process, cutie-iterator, cutie-path, cutie-if-else, cutie-cluster, page-static-generator and many others.

cutie's Issues

check error in callback (throw it in asyncCall) case

definedAsyncCall -> asyncCall, definedSyncCall -> syncCall, get rid of instatnce of AsyncObject

fix travis config: npm publish on merge to master

update wall and add total coverage info

Restriction for Event's body

Event's body must return async object

add travis ci

Fix eslint config

Signature of sync/async calls' definition

Instead of

definedAsyncCall() { return (...args) => { /* ... */ } }

do:

definedSyncCall(...args) { /* ... */ }

The same for sync call

Refactor with decorators

Refactor Cutie using decorators

Optimise number of check on pr

init gitlab ci

new logo

consider async object as decorator design pattern

Documentation of implementation AsyncTree Pattern

Write docs of how async tree is implemented in Cutie.

Refactor removing empty spaces in code, make new methods(private)

Instance of tree need to be created in call method of AsyncObject, not in constructor.

Let Event implement AsyncObject interface.

Sometimes it's useful to use Event as AsyncObject (pass some async objects as encapsulated arguments into Event).

Get rid of // It's not possible to get rid of null here :(

freeze represented objects(values)

Release to github does not work

add logo from logos

Revert new signature

Revert new signature, because it's not so obvious in cases like fs.readFile, where you don't need to pass params to async call.

Improve coverage

test coverage badge

improve checkstyle

Prohibit saving value on existing key in as function

deploy release via travis

As abstraction

Consider As abstraction (for cache),
For example:

As('A2')(
   A1(),
   A2().as('A2'),
   A3()
),

where As('A2') is the represented result of A2()

Docs:improve it, make less external links, add contents

init wall

Init fortress ci

remove all shitty heavy deps

Unexpected behavior on synchronous call

Hi, Guseyn!
I tried your framework and got unexpected behavior with synchronous call.

For example, i want to create two classes with sync and async behavior, for read and write files.

WrittenFile

const AsyncObject = require('@cuties/cutie').AsyncObject
const fs = require('fs')

class WrittenFile extends AsyncObject {
    constructor(path, content) {
        super(path, content);
    }

    asyncCall() {
        return (path, content, callback) => {
            this.path = path;
            fs.writeFile(path, content, callback)
            console.log("asyncCall writtenFile");
        }
    }

    syncCall() {
        return (path, content, callback) => {
            this.path = path;
            fs.writeFileSync(path, content, callback)
            console.log("syncCall writtenFile");
        }
    }

    onResult() {
        console.log("writtenFile has done!");
    }
}

module.exports = WrittenFile;

ReadDataByPath

const AsyncObject = require('@cuties/cutie').AsyncObject
const fs = require('fs')

class ReadDataByPath extends AsyncObject {
  constructor (path, encoding) {
    super(path, encoding);
  }
  
  asyncCall () {
    return fs.readFile
  }

  syncCall() {
      return fs.readFileSync
  }
}

module.exports = ReadDataByPath

And if i want to run as sync operation, i do

new WrittenFile(
    'package2.json',
    new ReadDataByPath('package.json', 'utf-8')
).syncCall();

but nothing happens.

How can i create one class with two behaviors (async and sync)?

Improve As conception

Add as() method to AsyncObject that can cache value.
Now As can be used only for retrieving values from the cache (can accept only one argument, which is key cached value).

Update async tree pattern docs

After

Create and implement after conception:

A1(
  A2(), A3()
).after(
  A4(
    A5(), A6()
  )
).call()

SyncObject

Actually it's more clear if SyncObject would be introduced, so in the whole we'll have three abstractions: AsyncObject, SyncObject and Event.

Async Monad instead of Async Object