beelzebub
Version:
One Hell of a Task Master!
1,639 lines (1,240 loc) • 35.1 kB
Markdown
# beelzebub - Task Class (v1.0.4)
<!-- div class="toc-container" -->
<!-- div -->
## `Methods`
* <a href="#$addSubTasks">`$addSubTasks`</a>
* <a href="#$afterAll">`$afterAll`</a>
* <a href="#$afterEach">`$afterEach`</a>
* <a href="#$beforeAll">`$beforeAll`</a>
* <a href="#$beforeEach">`$beforeEach`</a>
* <a href="#$config">`$config`</a>
* <a href="#$defineTaskVars">`$defineTaskVars`</a>
* <a href="#$getGlobalVars">`$getGlobalVars`</a>
* <a href="#$getName">`$getName`</a>
* <a href="#$getRunning">`$getRunning`</a>
* <a href="#$getStatsSummary">`$getStatsSummary`</a>
* <a href="#$getSubTask">`$getSubTask`</a>
* <a href="#$getSubTasks">`$getSubTasks`</a>
* <a href="#$getTask">`$getTask`</a>
* <a href="#$getTaskFlatList">`$getTaskFlatList`</a>
* <a href="#$getTaskTree">`$getTaskTree`</a>
* <a href="#$getVarDefsForTaskName">`$getVarDefsForTaskName`</a>
* <a href="#$hasRunBefore">`$hasRunBefore`</a>
* <a href="#$hasSubTask">`$hasSubTask`</a>
* <a href="#$hasTask">`$hasTask`</a>
* <a href="#$init">`$init`</a>
* <a href="#$isRoot">`$isRoot`</a>
* <a href="#$parallel">`$parallel`</a>
* <a href="#$printHelp">`$printHelp`</a>
* <a href="#$register">`$register`</a>
* <a href="#$run">`$run`</a>
* <a href="#$sequence">`$sequence`</a>
* <a href="#$setDefault">`$setDefault`</a>
* <a href="#$setGlobalVars">`$setGlobalVars`</a>
* <a href="#$setName">`$setName`</a>
* <a href="#$setSubTask">`$setSubTask`</a>
* <a href="#$setSubTasks">`$setSubTasks`</a>
* <a href="#$setTaskHelpDocs">`$setTaskHelpDocs`</a>
* <a href="#$useAsRoot">`$useAsRoot`</a>
<!-- /div -->
<!-- /div -->
<!-- div class="doc-container" -->
<!-- div -->
## `Methods`
<!-- div -->
<h3 id="$addSubTasks"><a href="#$addSubTasks">#</a> <code>$addSubTasks(Task, [config={}])</code></h3>
[Ⓢ](../lib/bzTasks.js#L515 "View in source") [Ⓣ][1]
Add Sub Tasks
#### Arguments
1. `Task` *(object)*: Task Class
2. `[config={}]` *(object)*: Config for Task
#### Returns
*(object)*: Promise
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MyBaseTasks extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$setName(config.name || 'MyBaseTasks');
this.value = config.value;
this._delayTime = 300;
}
$init () {
return this._delay('MyBaseTasks init');
}
_delay (message) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, this._delayTime);
});
}
task1 () {
return this._delay('MyBaseTasks task1 - ' + this.value);
}
}
class MyTasks extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$setName('MyTasks');
}
$init () {
this.logger.log('MyTasks init');
// simlate tasks dynamiclly added after some async event
return new Promise((resolve, reject) => {
setTimeout(() => {
this.$addSubTasks(MyBaseTasks, { name: 'MyBaseTasks1', value: 123 });
this.$addSubTasks(MyBaseTasks, { name: 'MyBaseTasks2', value: 456 });
// done
resolve(1234);
}, 200);
});
}
task1 () {
this.logger.log('MyTasks task1');
return this.$sequence('MyTasks.MyBaseTasks1.task1', 'MyTasks.MyBaseTasks2.task1');
}
}
bz.add(MyTasks);
let p = bz.run('MyTasks.task1');
/* Output:
MyTasks init
MyBaseTasks init
MyBaseTasks init
MyTasks task1
MyBaseTasks task1 - 123
MyBaseTasks task1 - 456
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$afterAll"><a href="#$afterAll">#</a> <code>$afterAll()</code></h3>
[Ⓢ](../lib/bzTasks.js#L368 "View in source") [Ⓣ][1]
This should to be Extented
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MySubBaseTasks1 extends Beelzebub.Tasks {
_delay (message, delay = 100) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
$init () {
this.logger.log('MySubBaseTasks1 init');
}
// generator function
* $beforeAll (taskInfo) {
yield this._delay(`MySubBaseTasks1 beforeAll - ${taskInfo.task}`);
}
// generator function
* $afterAll () {
return this._delay('MySubBaseTasks1 afterAll');
}
// generator function
* $beforeEach (taskInfo) {
return this._delay(`MySubBaseTasks1 beforeEach - ${taskInfo.task}`);
}
// generator function
* $afterEach (taskInfo) {
yield this._delay(`MySubBaseTasks1 afterEach - ${taskInfo.task}`);
}
taskA1 () {
return this._delay('MySubBaseTasks1 taskA1');
}
}
class MySubBaseTasks2 extends Beelzebub.Tasks {
_delay (message, delay = 100) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
$init () {
this.logger.log('MySubBaseTasks2 init');
}
// generator function
* $beforeAll (taskInfo) {
yield this._delay(`MySubBaseTasks2 beforeAll - ${taskInfo.task}`);
}
// generator function
* $afterAll () {
return this._delay('MySubBaseTasks2 afterAll');
}
// generator function
* $beforeEach (taskInfo) {
return this._delay(`MySubBaseTasks2 beforeEach - ${taskInfo.task}`);
}
// generator function
* $afterEach (taskInfo) {
yield this._delay(`MySubBaseTasks2 afterEach - ${taskInfo.task}`);
}
taskA2 () {
return this._delay('MySubBaseTasks2 taskA2');
}
}
class MyBaseTasks extends Beelzebub.Tasks {
_delay (message, delay = 100) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
$init () {
this.logger.log('MyBaseTasks init');
// see subtasksSimple or Advanced for details on adding sub tasks
this.$addSubTasks(MySubBaseTasks1);
}
// returns promise
$beforeAll (taskInfo) {
return this._delay(`MyBaseTasks beforeAll - ${taskInfo.task}`).then(() => {
return this.$addSubTasks(MySubBaseTasks2);
});
}
// returns promise
$afterAll () {
return this._delay('MyBaseTasks afterAll');
}
// returns promise
$beforeEach (taskInfo) {
return this._delay(`MyBaseTasks beforeEach - ${taskInfo.task} ${JSON.stringify(taskInfo.vars)}`);
}
// returns promise
$afterEach (taskInfo) {
return this._delay(`MyBaseTasks afterEach - ${taskInfo.task} ${JSON.stringify(taskInfo.vars)}`);
}
taskA (vars) {
return this._delay(`MyBaseTasks taskA - ${vars.hello}`);
}
taskB (vars) {
return this._delay('MyBaseTasks taskB');
}
}
class MyTasks extends Beelzebub.Tasks {
_delay (message, delay = 100) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
$init () {
this.logger.log('MyTasks init');
// see subtasksSimple or Advanced for details on adding sub tasks
this.$addSubTasks(MyBaseTasks);
}
// generator function
* $beforeEach (taskInfo) {
yield this._delay(`MyTasks beforeEach - ${taskInfo.task}`);
}
// generator function
* $afterEach (taskInfo) {
yield this._delay(`MyTasks afterEach - ${taskInfo.task}`);
}
// generator function
* $beforeAll (taskInfo) {
yield this._delay(`MyTasks beforeAll - ${taskInfo.task}`);
}
// generator function
* $afterAll () {
yield this._delay(`MyTasks afterAll`);
}
task1 () {
this.logger.log('MyTasks task1');
return this.$sequence({
task: '.MyBaseTasks.taskA',
vars: { hello: 'world' }
},
'.MyBaseTasks.taskB',
'.MyBaseTasks.MySubBaseTasks2.taskA2');
}
task2 () {
this.logger.log('MyTasks task2');
}
_internalFunction () {
this.logger.error('this should be ignored');
}
}
bz.add(MyTasks);
let p = bz.run('MyTasks.MyBaseTasks.MySubBaseTasks1.taskA1', 'MyTasks.task1', 'MyTasks.task2');
/* Output:
MyTasks init
MyBaseTasks init
MySubBaseTasks1 init
MyTasks beforeAll - taskA1
MyBaseTasks beforeAll - taskA1
MySubBaseTasks2 init
MySubBaseTasks1 beforeAll - taskA1
MySubBaseTasks1 beforeEach - taskA1
MySubBaseTasks1 taskA1
MySubBaseTasks1 afterEach - taskA1
MyTasks beforeEach - task1
MyTasks task1
MyBaseTasks beforeEach - taskA {"hello":"world"}
MyBaseTasks taskA - world
MyBaseTasks afterEach - taskA {"hello":"world"}
MyBaseTasks beforeEach - taskB {}
MyBaseTasks taskB
MyBaseTasks afterEach - taskB {}
MySubBaseTasks2 beforeAll - taskA2
MySubBaseTasks2 beforeEach - taskA2
MySubBaseTasks2 taskA2
MySubBaseTasks2 afterEach - taskA2
MyTasks afterEach - task1
MyTasks beforeEach - task2
MyTasks task2
MyTasks afterEach - task2
MySubBaseTasks1 afterAll
MySubBaseTasks2 afterAll
MyBaseTasks afterAll
MyTasks afterAll
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$afterEach"><a href="#$afterEach">#</a> <code>$afterEach(taskInfo)</code></h3>
[Ⓢ](../lib/bzTasks.js#L351 "View in source") [Ⓣ][1]
This should to be Extented
#### Arguments
1. `taskInfo` *(object)*: {name, vars}
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MyTasks extends Beelzebub.Tasks {
$beforeEach (taskInfo) {
this.logger.log(`MyTasks beforeEach - ${taskInfo.task}`);
}
$afterEach (taskInfo) {
this.logger.log(`MyTasks afterEach - ${taskInfo.task}`);
}
$beforeAll () {
this.logger.log(`MyTasks beforeAll`);
}
$afterAll () {
this.logger.log(`MyTasks afterAll`);
}
// my tasks
task1 () {
this.logger.log('MyTasks task1');
}
task2 () {
this.logger.log('MyTasks task2');
}
}
bz.add(MyTasks);
let p = bz.run('MyTasks.task1', 'MyTasks.task2');
/* Output:
MyTasks beforeAll
MyTasks beforeEach - task1
MyTasks task1
MyTasks afterEach - task1
MyTasks beforeEach - task2
MyTasks task2
MyTasks afterEach - task2
MyTasks afterAll
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$beforeAll"><a href="#$beforeAll">#</a> <code>$beforeAll(taskInfo)</code></h3>
[Ⓢ](../lib/bzTasks.js#L360 "View in source") [Ⓣ][1]
This should to be Extented
#### Arguments
1. `taskInfo` *(object)*: {name, vars}
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MySubBaseTasks1 extends Beelzebub.Tasks {
_delay (message, delay = 100) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
$init () {
this.logger.log('MySubBaseTasks1 init');
}
// generator function
* $beforeAll (taskInfo) {
yield this._delay(`MySubBaseTasks1 beforeAll - ${taskInfo.task}`);
}
// generator function
* $afterAll () {
return this._delay('MySubBaseTasks1 afterAll');
}
// generator function
* $beforeEach (taskInfo) {
return this._delay(`MySubBaseTasks1 beforeEach - ${taskInfo.task}`);
}
// generator function
* $afterEach (taskInfo) {
yield this._delay(`MySubBaseTasks1 afterEach - ${taskInfo.task}`);
}
taskA1 () {
return this._delay('MySubBaseTasks1 taskA1');
}
}
class MySubBaseTasks2 extends Beelzebub.Tasks {
_delay (message, delay = 100) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
$init () {
this.logger.log('MySubBaseTasks2 init');
}
// generator function
* $beforeAll (taskInfo) {
yield this._delay(`MySubBaseTasks2 beforeAll - ${taskInfo.task}`);
}
// generator function
* $afterAll () {
return this._delay('MySubBaseTasks2 afterAll');
}
// generator function
* $beforeEach (taskInfo) {
return this._delay(`MySubBaseTasks2 beforeEach - ${taskInfo.task}`);
}
// generator function
* $afterEach (taskInfo) {
yield this._delay(`MySubBaseTasks2 afterEach - ${taskInfo.task}`);
}
taskA2 () {
return this._delay('MySubBaseTasks2 taskA2');
}
}
class MyBaseTasks extends Beelzebub.Tasks {
_delay (message, delay = 100) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
$init () {
this.logger.log('MyBaseTasks init');
// see subtasksSimple or Advanced for details on adding sub tasks
this.$addSubTasks(MySubBaseTasks1);
}
// returns promise
$beforeAll (taskInfo) {
return this._delay(`MyBaseTasks beforeAll - ${taskInfo.task}`).then(() => {
return this.$addSubTasks(MySubBaseTasks2);
});
}
// returns promise
$afterAll () {
return this._delay('MyBaseTasks afterAll');
}
// returns promise
$beforeEach (taskInfo) {
return this._delay(`MyBaseTasks beforeEach - ${taskInfo.task} ${JSON.stringify(taskInfo.vars)}`);
}
// returns promise
$afterEach (taskInfo) {
return this._delay(`MyBaseTasks afterEach - ${taskInfo.task} ${JSON.stringify(taskInfo.vars)}`);
}
taskA (vars) {
return this._delay(`MyBaseTasks taskA - ${vars.hello}`);
}
taskB (vars) {
return this._delay('MyBaseTasks taskB');
}
}
class MyTasks extends Beelzebub.Tasks {
_delay (message, delay = 100) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
$init () {
this.logger.log('MyTasks init');
// see subtasksSimple or Advanced for details on adding sub tasks
this.$addSubTasks(MyBaseTasks);
}
// generator function
* $beforeEach (taskInfo) {
yield this._delay(`MyTasks beforeEach - ${taskInfo.task}`);
}
// generator function
* $afterEach (taskInfo) {
yield this._delay(`MyTasks afterEach - ${taskInfo.task}`);
}
// generator function
* $beforeAll (taskInfo) {
yield this._delay(`MyTasks beforeAll - ${taskInfo.task}`);
}
// generator function
* $afterAll () {
yield this._delay(`MyTasks afterAll`);
}
task1 () {
this.logger.log('MyTasks task1');
return this.$sequence({
task: '.MyBaseTasks.taskA',
vars: { hello: 'world' }
},
'.MyBaseTasks.taskB',
'.MyBaseTasks.MySubBaseTasks2.taskA2');
}
task2 () {
this.logger.log('MyTasks task2');
}
_internalFunction () {
this.logger.error('this should be ignored');
}
}
bz.add(MyTasks);
let p = bz.run('MyTasks.MyBaseTasks.MySubBaseTasks1.taskA1', 'MyTasks.task1', 'MyTasks.task2');
/* Output:
MyTasks init
MyBaseTasks init
MySubBaseTasks1 init
MyTasks beforeAll - taskA1
MyBaseTasks beforeAll - taskA1
MySubBaseTasks2 init
MySubBaseTasks1 beforeAll - taskA1
MySubBaseTasks1 beforeEach - taskA1
MySubBaseTasks1 taskA1
MySubBaseTasks1 afterEach - taskA1
MyTasks beforeEach - task1
MyTasks task1
MyBaseTasks beforeEach - taskA {"hello":"world"}
MyBaseTasks taskA - world
MyBaseTasks afterEach - taskA {"hello":"world"}
MyBaseTasks beforeEach - taskB {}
MyBaseTasks taskB
MyBaseTasks afterEach - taskB {}
MySubBaseTasks2 beforeAll - taskA2
MySubBaseTasks2 beforeEach - taskA2
MySubBaseTasks2 taskA2
MySubBaseTasks2 afterEach - taskA2
MyTasks afterEach - task1
MyTasks beforeEach - task2
MyTasks task2
MyTasks afterEach - task2
MySubBaseTasks1 afterAll
MySubBaseTasks2 afterAll
MyBaseTasks afterAll
MyTasks afterAll
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$beforeEach"><a href="#$beforeEach">#</a> <code>$beforeEach(taskInfo)</code></h3>
[Ⓢ](../lib/bzTasks.js#L342 "View in source") [Ⓣ][1]
This should to be Extented
#### Arguments
1. `taskInfo` *(object)*: {name, vars}
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MyTasks extends Beelzebub.Tasks {
$beforeEach (taskInfo) {
this.logger.log(`MyTasks beforeEach - ${taskInfo.task}`);
}
$afterEach (taskInfo) {
this.logger.log(`MyTasks afterEach - ${taskInfo.task}`);
}
$beforeAll () {
this.logger.log(`MyTasks beforeAll`);
}
$afterAll () {
this.logger.log(`MyTasks afterAll`);
}
// my tasks
task1 () {
this.logger.log('MyTasks task1');
}
task2 () {
this.logger.log('MyTasks task2');
}
}
bz.add(MyTasks);
let p = bz.run('MyTasks.task1', 'MyTasks.task2');
/* Output:
MyTasks beforeAll
MyTasks beforeEach - task1
MyTasks task1
MyTasks afterEach - task1
MyTasks beforeEach - task2
MyTasks task2
MyTasks afterEach - task2
MyTasks afterAll
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$config"><a href="#$config">#</a> <code>$config()</code></h3>
[Ⓢ](../lib/bzTasks.js#L147 "View in source") [Ⓣ][1]
Gets Current Config
#### Returns
*(object)*: config
---
<!-- /div -->
<!-- div -->
<h3 id="$defineTaskVars"><a href="#$defineTaskVars">#</a> <code>$defineTaskVars(taskName, taskDef)</code></h3>
[Ⓢ](../lib/bzTasks.js#L279 "View in source") [Ⓣ][1]
Define Task Vars
#### Arguments
1. `taskName` *(string)*: Name of Task
2. `taskDef` *(object)*: Var Defintion for Task
#### Example
```js
const Beelzebub = require('../../');
const bz = Beelzebub(options || { verbose: true });
const task = Beelzebub.TmplStrFunc.task;
class MyTasks extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$defineTaskVars('task1', {
name: { type: 'String', default: 'hello' },
flag: { type: 'Boolean', default: true }
});
this.$defineTaskVars('task2', {
count: { type: 'Number', required: true },
verbose: { type: 'Boolean', alias: 'v', default: false }
});
this.$defineTaskVars('task3', {
fullname: {
type: 'Object',
properties: {
first: { type: 'String' },
last: { type: 'String' }
}
},
list: {
type: 'Array',
items: { type: 'String' }
}
});
}
task1 (customVars) {
this.logger.log(`MyTasks task1 - ${JSON.stringify(this.$getGlobalVars())} ${customVars.name} ${customVars.flag}`);
}
task2 (customVars) {
this.logger.log(`MyTasks task2 - ${customVars.count} ${customVars.verbose}`);
}
task3 (customVars) {
this.logger.log(`MyTasks task3 - "${customVars.fullname.first} ${customVars.fullname.last}" ${customVars.list}`);
}
}
bz.add(MyTasks);
let p = bz.run(
'MyTasks.task1',
task`MyTasks.task2:${{count: 100, verbose: true}}`,
{
task: 'MyTasks.task3',
vars: {
fullname: { first: 'hello', last: 'world' },
list: [ 'te', 'st' ]
}
}
);
/* Output:
MyTasks task1 - {} hello true
MyTasks task2 - 100 true
MyTasks task3 - "hello world" te,st
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$getGlobalVars"><a href="#$getGlobalVars">#</a> <code>$getGlobalVars()</code></h3>
[Ⓢ](../lib/bzTasks.js#L269 "View in source") [Ⓣ][1]
Get Global Vars
#### Returns
*(object)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$getName"><a href="#$getName">#</a> <code>$getName()</code></h3>
[Ⓢ](../lib/bzTasks.js#L197 "View in source") [Ⓣ][1]
Get name of Task Group/Class
#### Returns
*(string)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$getRunning"><a href="#$getRunning">#</a> <code>$getRunning()</code></h3>
[Ⓢ](../lib/bzTasks.js#L376 "View in source") [Ⓣ][1]
Is Task Running?
#### Returns
*(boolean)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$getStatsSummary"><a href="#$getStatsSummary">#</a> <code>$getStatsSummary()</code></h3>
[Ⓢ](../lib/bzTasks.js#L114 "View in source") [Ⓣ][1]
Get task status and all it's sub tasks stats
#### Returns
*(object)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$getSubTask"><a href="#$getSubTask">#</a> <code>$getSubTask(name)</code></h3>
[Ⓢ](../lib/bzTasks.js#L223 "View in source") [Ⓣ][1]
Get SubTask by Name
#### Arguments
1. `name` *(string)*: Name of Sub Task
#### Returns
*(object)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$getSubTasks"><a href="#$getSubTasks">#</a> <code>$getSubTasks()</code></h3>
[Ⓢ](../lib/bzTasks.js#L247 "View in source") [Ⓣ][1]
Get All Sub Task(s)
#### Returns
*(object)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$getTask"><a href="#$getTask">#</a> <code>$getTask(name)</code></h3>
[Ⓢ](../lib/bzTasks.js#L206 "View in source") [Ⓣ][1]
Get Task by Name
#### Arguments
1. `name` *(string)*: Name of Task to get
#### Returns
*(function)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$getTaskFlatList"><a href="#$getTaskFlatList">#</a> <code>$getTaskFlatList()</code></h3>
[Ⓢ](../lib/bzTasks.js#L93 "View in source") [Ⓣ][1]
Get flatten task tree so it's one level
#### Returns
*(object)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$getTaskTree"><a href="#$getTaskTree">#</a> <code>$getTaskTree()</code></h3>
[Ⓢ](../lib/bzTasks.js#L60 "View in source") [Ⓣ][1]
Get Task Tree starting with this task
#### Returns
*(object)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$getVarDefsForTaskName"><a href="#$getVarDefsForTaskName">#</a> <code>$getVarDefsForTaskName(taskStr)</code></h3>
[Ⓢ](../lib/bzTasks.js#L306 "View in source") [Ⓣ][1]
Get Define Task Vars by Name
#### Arguments
1. `taskStr` *(string)*: Name of Task
#### Returns
*(object)*: Varaible Definition for Task
---
<!-- /div -->
<!-- div -->
<h3 id="$hasRunBefore"><a href="#$hasRunBefore">#</a> <code>$hasRunBefore()</code></h3>
[Ⓢ](../lib/bzTasks.js#L173 "View in source") [Ⓣ][1]
Has any of the tasks ran before?
#### Returns
*(boolean)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$hasSubTask"><a href="#$hasSubTask">#</a> <code>$hasSubTask(name)</code></h3>
[Ⓢ](../lib/bzTasks.js#L239 "View in source") [Ⓣ][1]
Does this have a Sub Task with the name?
#### Arguments
1. `name` *(string)*: Name of Sub Task
#### Returns
*(boolean)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$hasTask"><a href="#$hasTask">#</a> <code>$hasTask(name)</code></h3>
[Ⓢ](../lib/bzTasks.js#L214 "View in source") [Ⓣ][1]
Does this Task Group have a Task with the name?
#### Arguments
1. `name` *(string)*: Name of Task
#### Returns
*(boolean)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$init"><a href="#$init">#</a> <code>$init()</code></h3>
[Ⓢ](../lib/bzTasks.js#L333 "View in source") [Ⓣ][1]
This should be Extented
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MyBaseTasks extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$setName(config.name || 'MyBaseTasks');
this.value = config.value;
this._delayTime = 300;
}
$init () {
return this._delay('MyBaseTasks init');
}
_delay (message) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, this._delayTime);
});
}
task1 () {
return this._delay('MyBaseTasks task1 - ' + this.value);
}
}
class MyTasks extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$setName('MyTasks');
}
$init () {
this.logger.log('MyTasks init');
// simlate tasks dynamiclly added after some async event
return new Promise((resolve, reject) => {
setTimeout(() => {
this.$addSubTasks(MyBaseTasks, { name: 'MyBaseTasks1', value: 123 });
this.$addSubTasks(MyBaseTasks, { name: 'MyBaseTasks2', value: 456 });
// done
resolve(1234);
}, 200);
});
}
task1 () {
this.logger.log('MyTasks task1');
return this.$sequence('MyTasks.MyBaseTasks1.task1', 'MyTasks.MyBaseTasks2.task1');
}
}
bz.add(MyTasks);
let p = bz.run('MyTasks.task1');
/* Output:
MyTasks init
MyBaseTasks init
MyBaseTasks init
MyTasks task1
MyBaseTasks task1 - 123
MyBaseTasks task1 - 456
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$isRoot"><a href="#$isRoot">#</a> <code>$isRoot()</code></h3>
[Ⓢ](../lib/bzTasks.js#L181 "View in source") [Ⓣ][1]
Is this task root level?
#### Returns
*(boolean)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$parallel"><a href="#$parallel">#</a> <code>$parallel(args)</code></h3>
[Ⓢ](../lib/bzTasks.js#L651 "View in source") [Ⓣ][1]
Runs task(s) in parallel
#### Arguments
1. `args` *(function|string): task(s)*
#### Returns
*(object)*: Promise
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MyTasks extends Beelzebub.Tasks {
_delay (message, delay = 300) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
task1 () {
this.logger.log('MyTasks task1');
return this.$parallel('.task3', '.task4');
}
task2 () {
return this._delay('MyTasks task2', 200);
}
task3 () {
this.logger.log('MyTasks task3');
return this.$run(['.task5', '.task6']);
}
task4 () {
return this._delay('MyTasks task4', 400);
}
task5 () {
this.logger.log('MyTasks task5');
}
task6 () {
return this._delay('MyTasks task6', 600);
}
}
bz.add(MyTasks);
// arrays are run in parallel
let p = bz.run(['MyTasks.task1', 'MyTasks.task2']);
/* Output:
MyTasks task1
MyTasks task3
MyTasks task5
MyTasks task2
MyTasks task4
MyTasks task6
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$printHelp"><a href="#$printHelp">#</a> <code>$printHelp()</code></h3>
[Ⓢ](../lib/bzTasks.js#L128 "View in source") [Ⓣ][1]
Prints Task help and all sub tasks help
#### Example
```js
const Beelzebub = require('../../');
const bz = Beelzebub(options || { verbose: true });
class MyTasks extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$setDefault('task1');
this.$setTaskHelpDocs('task1', 'ES7 Decorator Example MyTasks - Task 1');
this.$setTaskHelpDocs('task2', 'ES7 Decorator Example MyTasks - Task 2');
}
task1 () {
this.logger.log('MyTasks task1');
}
task2 () {
this.logger.log('MyTasks task2');
}
}
bz.add(MyTasks);
class MyTasks2 extends bz.Tasks {
constructor (config) {
super(config);
this.$setDefault('task1');
this.$setTaskHelpDocs('task1', 'ES7 Decorator Example MyTasks2 - Task 1');
this.$setTaskHelpDocs('task2', 'ES7 Decorator Example MyTasks2 - Task 2');
}
task1 () {
this.logger.log('MyTasks2 task1');
}
task2 () {
this.logger.log('MyTasks2 task2');
}
}
bz.add(MyTasks2);
let p = bz.run('MyTasks', 'MyTasks.task2', 'MyTasks2', 'MyTasks2.task2');
// prints help results
// bz.printHelp();
/* Output:
MyTasks task1
MyTasks task2
MyTasks2 task1
MyTasks2 task2
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$register"><a href="#$register">#</a> <code>$register()</code></h3>
[Ⓢ](../lib/bzTasks.js#L384 "View in source") [Ⓣ][1]
Register the Task with BZ
#### Returns
*(object)*: Promise
---
<!-- /div -->
<!-- div -->
<h3 id="$run"><a href="#$run">#</a> <code>$run(args)</code></h3>
[Ⓢ](../lib/bzTasks.js#L661 "View in source") [Ⓣ][1]
Runs task(s) - multi args run in sequence, arrays are run in parallel
#### Arguments
1. `args` *(function|string): task(s)*
#### Returns
*(object)*: Promise
---
<!-- /div -->
<!-- div -->
<h3 id="$sequence"><a href="#$sequence">#</a> <code>$sequence(args)</code></h3>
[Ⓢ](../lib/bzTasks.js#L640 "View in source") [Ⓣ][1]
Runs task(s) in sequence
#### Arguments
1. `args` *(object|string): task(s)*
#### Returns
*(Object)*: Promise
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MyTasks extends Beelzebub.Tasks {
_delay (message, delay = 300) {
return new Promise((resolve, reject) => {
setTimeout(() => {
this.logger.log(message);
resolve();
}, delay);
});
}
task1 () {
this.logger.log('MyTasks task1');
return this.$sequence('.task3', '.task4');
}
task2 () {
return this._delay('MyTasks task2', 200);
}
task3 () {
this.logger.log('MyTasks task3');
return this.$run('.task5', '.task6');
}
task4 () {
return this._delay('MyTasks task4', 400);
}
task5 () {
this.logger.log('MyTasks task5');
}
task6 () {
return this._delay('MyTasks task6', 600);
}
}
bz.add(MyTasks);
// params are run in sequence
let p = bz.run('MyTasks.task1', 'MyTasks.task2');
/* Output:
MyTasks task1
MyTasks task3
MyTasks task5
MyTasks task6
MyTasks task4
MyTasks task2
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$setDefault"><a href="#$setDefault">#</a> <code>$setDefault(taskFuncName)</code></h3>
[Ⓢ](../lib/bzTasks.js#L165 "View in source") [Ⓣ][1]
Set a Task as default
#### Arguments
1. `taskFuncName` *(string): This Class *(Task)** function name
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MyRootLevel extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$useAsRoot();
}
task1 () {
this.logger.log('MyRootLevel task1');
}
task2 () {
this.logger.log('MyRootLevel task2');
}
}
class MyTasks1 extends Beelzebub.Tasks {
default () {
this.logger.log('MyTasks1 default');
}
}
class MyTasks2 extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$setDefault('myDefault');
}
myDefault () {
this.logger.log('MyTasks2 myDefault');
}
}
bz.add(MyRootLevel);
bz.add(MyTasks1);
bz.add(MyTasks2);
let p = bz.run(
'task1',
'task2',
'MyTasks1',
'MyTasks1.default',
'MyTasks2',
'MyTasks2.myDefault'
);
/* Output:
MyRootLevel task1
MyRootLevel task2
MyTasks1 default
MyTasks1 default
MyTasks2 myDefault
MyTasks2 myDefault
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$setGlobalVars"><a href="#$setGlobalVars">#</a> <code>$setGlobalVars(vars)</code></h3>
[Ⓢ](../lib/bzTasks.js#L262 "View in source") [Ⓣ][1]
Set Global Vars
#### Arguments
1. `vars` *(object)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$setName"><a href="#$setName">#</a> <code>$setName(name)</code></h3>
[Ⓢ](../lib/bzTasks.js#L189 "View in source") [Ⓣ][1]
Set name of Task Group/Class, when refering to Task Group in CLI or other Tasks
#### Arguments
1. `name` *(string)*: New name of Task Group/Class
---
<!-- /div -->
<!-- div -->
<h3 id="$setSubTask"><a href="#$setSubTask">#</a> <code>$setSubTask(name, task)</code></h3>
[Ⓢ](../lib/bzTasks.js#L231 "View in source") [Ⓣ][1]
Set SubTask
#### Arguments
1. `name` *(string)*: Name of Sub Task
2. `task` *(string)*: Task Class
---
<!-- /div -->
<!-- div -->
<h3 id="$setSubTasks"><a href="#$setSubTasks">#</a> <code>$setSubTasks(tasks)</code></h3>
[Ⓢ](../lib/bzTasks.js#L254 "View in source") [Ⓣ][1]
Set All Sub Task(s)
#### Arguments
1. `tasks` *(object)*:
---
<!-- /div -->
<!-- div -->
<h3 id="$setTaskHelpDocs"><a href="#$setTaskHelpDocs">#</a> <code>$setTaskHelpDocs(taskName, helpDocs)</code></h3>
[Ⓢ](../lib/bzTasks.js#L293 "View in source") [Ⓣ][1]
Set Help Docs for Task
#### Arguments
1. `taskName` *(string)*: Name of Task
2. `helpDocs` *(string)*: Help Docs for Task
#### Example
```js
const Beelzebub = require('../../');
const bz = Beelzebub(options || { verbose: true });
class MyTasks extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$setDefault('task1');
this.$setTaskHelpDocs('task1', 'ES7 Decorator Example MyTasks - Task 1');
this.$setTaskHelpDocs('task2', 'ES7 Decorator Example MyTasks - Task 2');
}
task1 () {
this.logger.log('MyTasks task1');
}
task2 () {
this.logger.log('MyTasks task2');
}
}
bz.add(MyTasks);
class MyTasks2 extends bz.Tasks {
constructor (config) {
super(config);
this.$setDefault('task1');
this.$setTaskHelpDocs('task1', 'ES7 Decorator Example MyTasks2 - Task 1');
this.$setTaskHelpDocs('task2', 'ES7 Decorator Example MyTasks2 - Task 2');
}
task1 () {
this.logger.log('MyTasks2 task1');
}
task2 () {
this.logger.log('MyTasks2 task2');
}
}
bz.add(MyTasks2);
let p = bz.run('MyTasks', 'MyTasks.task2', 'MyTasks2', 'MyTasks2.task2');
// prints help results
// bz.printHelp();
/* Output:
MyTasks task1
MyTasks task2
MyTasks2 task1
MyTasks2 task2
*/
```
---
<!-- /div -->
<!-- div -->
<h3 id="$useAsRoot"><a href="#$useAsRoot">#</a> <code>$useAsRoot()</code></h3>
[Ⓢ](../lib/bzTasks.js#L155 "View in source") [Ⓣ][1]
Use this Task as root task
#### Example
```js
let Beelzebub = require('../../');
let bz = Beelzebub(options || { verbose: true });
class MyRootLevel extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$useAsRoot();
}
task1 () {
this.logger.log('MyRootLevel task1');
}
task2 () {
this.logger.log('MyRootLevel task2');
}
}
class MyTasks1 extends Beelzebub.Tasks {
default () {
this.logger.log('MyTasks1 default');
}
}
class MyTasks2 extends Beelzebub.Tasks {
constructor (config) {
super(config);
this.$setDefault('myDefault');
}
myDefault () {
this.logger.log('MyTasks2 myDefault');
}
}
bz.add(MyRootLevel);
bz.add(MyTasks1);
bz.add(MyTasks2);
let p = bz.run(
'task1',
'task2',
'MyTasks1',
'MyTasks1.default',
'MyTasks2',
'MyTasks2.myDefault'
);
/* Output:
MyRootLevel task1
MyRootLevel task2
MyTasks1 default
MyTasks1 default
MyTasks2 myDefault
MyTasks2 myDefault
*/
```
---
<!-- /div -->
<!-- /div -->
<!-- /div -->
[1]: #methods "Jump back to the TOC."