octoparse-cli 0.1.14

package/node_modules/@octopus/bpmn/lib/gateways/ParallelGateway.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const Activity = require('../activities/Activity');
+
+function ParallelGateway() {
+  Activity.apply(this, arguments);
+  this.join = this.inbound.length > 1;
+  this.fork = this.outbound.length > 1;
+}
+
+ParallelGateway.prototype = Object.create(Activity.prototype);
+
+ParallelGateway.prototype.run = function() {
+  init.call(this);
+  continueRun.call(this);
+};
+
+function init() {
+  if (this.join) {
+    if (!this.pendingInbound) {
+      this.pendingInbound = this.inbound.slice();
+    }
+    this.pendingJoin = true;
+  }
+
+  if (this.fork) {
+    if (!this.pendingOutbound) {
+      this.pendingOutbound = this.outbound.slice();
+    }
+    this.pendingFork = true;
+  }
+
+  if (!this.discardedInbound) {
+    this.discardedInbound = [];
+  }
+
+  this.taken = false;
+  Activity.prototype.run.call(this);
+}
+
+ParallelGateway.prototype.activate = function() {
+  Activity.prototype.activate.apply(this, arguments);
+
+  this._onOutbound = this.onOutbound.bind(this);
+  this.outbound.forEach((flow) => {
+    flow.on('taken', this._onOutbound);
+    flow.on('discarded', this._onOutbound);
+  });
+};
+
+ParallelGateway.prototype.deactivate = function() {
+  Activity.prototype.deactivate.apply(this, arguments);
+  this.outbound.forEach((flow) => {
+    flow.removeListener('taken', this._onOutbound);
+    flow.removeListener('discarded', this._onOutbound);
+  });
+};
+
+ParallelGateway.prototype.onInbound = function(flow, rootFlow) {
+  if (!this.discardedInbound) {
+    init.call(this);
+  }
+
+  if (this.join) {
+    return runOnJoinInbound.call(this, flow, rootFlow);
+  }
+
+  return runOnInbound.call(this, flow, rootFlow);
+};
+
+function runOnJoinInbound(flow, rootFlow) {
+  if (flow.discarded) {
+    this.discardedInbound.push(flow);
+  }
+
+  const pendingIndex = this.pendingInbound.indexOf(flow);
+  this.pendingInbound.splice(pendingIndex, 1);
+
+  this._debug(`<${this.id}> join from ${flow.discarded ? 'discarded' : 'taken'} <${flow.id}> - pending ${this.pendingInbound.length}`);
+
+  if (this.pendingInbound.length === 0) {
+    this.pendingJoin = false;
+    return continueRun.call(this, rootFlow);
+  }
+
+  if (this.inbound.length - this.pendingInbound.length === 1) {
+    this.taken = true;
+    this.emit('start', this);
+  }
+}
+
+function runOnInbound(flow, rootFlow) {
+  if (flow.discarded) {
+    this.discardedInbound.push(flow);
+  }
+  return continueRun.call(this, rootFlow);
+}
+
+
+function continueRun(rootFlow) {
+  if (this.pendingJoin) return;
+
+  if (allInboundDiscarded.call(this)) {
+    return this.outbound.forEach((f) => f.discard(rootFlow));
+  }
+
+  if (this.pendingFork) {
+    return this.pendingOutbound.forEach((f) => f.take(rootFlow));
+  } else if (!this.isEnd) {
+    return this.outbound.forEach((f) => f.take(rootFlow));
+  }
+
+  this.complete();
+}
+
+ParallelGateway.prototype.onOutbound = function(flow) {
+  if (!this.pendingOutbound) return this.complete();
+
+  const idx = this.pendingOutbound.indexOf(flow);
+  this.pendingOutbound.splice(idx, 1);
+  this._debug(`<${this.id}> outbound flow <${flow.id}> ${flow.discarded ? 'discarded' : 'taken'} (${this.pendingOutbound.length})`);
+
+  if (!this.taken) {
+    this.taken = true;
+    this.emit('start', this);
+  }
+
+  if (this.pendingOutbound.length === 0) {
+    this._debug(`<${this.id}> all pending outbound completed`);
+    this.complete();
+  }
+};
+
+ParallelGateway.prototype.complete = function() {
+  const discard = allInboundDiscarded.call(this);
+
+  delete this.pendingInbound;
+  delete this.pendingOutbound;
+  delete this.discardedInbound;
+  this.pendingJoin = false;
+  this.pendingFork = false;
+
+  if (discard) {
+    this._debug(`<${this.id}>`, 'was discarded');
+  } else {
+    this.emit('end', this);
+  }
+
+  this.leave();
+};
+
+ParallelGateway.prototype.resume = function(state) {
+  if (state.hasOwnProperty('pendingJoin')) {
+    this.pendingJoin = state.pendingJoin;
+  }
+
+  if (state.pendingInbound) {
+    this.pendingInbound = state.pendingInbound.map((flowId) => this.inbound.find((flow) => flow.id === flowId));
+  }
+  if (state.discardedInbound) {
+    this.discardedInbound = state.discardedInbound.map((flowId) => this.inbound.find((flow) => flow.id === flowId));
+  }
+  if (state.pendingOutbound) {
+    this.pendingOutbound = state.pendingOutbound.map((flowId) => this.outbound.find((flow) => flow.id === flowId));
+  }
+
+  Activity.prototype.resume.apply(this, arguments);
+};
+
+ParallelGateway.prototype.getState = function() {
+  const state = Activity.prototype.getState.apply(this, arguments);
+
+  if (this.pendingJoin) {
+    state.pendingJoin = this.pendingJoin;
+  }
+  if (this.pendingInbound) {
+    state.pendingInbound = this.pendingInbound.map((flow) => flow.id);
+  }
+  if (this.discardedInbound) {
+    state.discardedInbound = this.discardedInbound.map((flow) => flow.id);
+  }
+
+  if (this.pendingOutbound) {
+    state.pendingOutbound = this.pendingOutbound.map((flow) => flow.id);
+  }
+
+  return state;
+};
+
+function allInboundDiscarded() {
+  if (this.isStart) return false;
+  return this.inbound.length === this.discardedInbound.length;
+}
+
+module.exports = ParallelGateway;

package/node_modules/@octopus/bpmn/lib/getPropertyValue.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const propertyPattern = /(\w+)\((.*?)(?:\))|(\.|\[|^)(.+?)(?:\]|\[|\.|$)/;
+const stringConstantPattern = /^['"](.*)['"]$/;
+const negativeIndexPattern = /^-\d+$/;
+
+function getPropertyValue(obj, propertyPath, defaultValue) {
+  if (!obj) return defaultValue;
+
+  let resultValue;
+  let next = iterateProps(obj, obj, propertyPath);
+  while (next) {
+    resultValue = next.getResult();
+    next = next();
+  }
+  return resultValue !== undefined ? resultValue : defaultValue;
+}
+
+function iterateProps(base, obj, propertyPath) {
+  let result;
+
+  const rest = propertyPath.replace(propertyPattern, (match, fnName, args, p, prop) => {
+    if (fnName) {
+      result = executeFn(getNamedValue(obj, fnName), args, base);
+    } else {
+      result = getNamedValue(obj, prop);
+    }
+    return '';
+  });
+
+  if (rest === propertyPath) return;
+  if (result === undefined) return;
+
+  const next = iterateProps.bind(null, base, result, rest);
+  next.getResult = () => {
+    if (rest !== '') return;
+    return result;
+  };
+
+  return next;
+}
+
+function executeFn(fn, args, base) {
+  if (!fn) return;
+
+  let callArguments = [];
+  if (args) {
+    callArguments = callArguments.concat(args.split(','));
+    callArguments = callArguments.map((argument) => {
+      return getFunctionArgument(base, argument, argument);
+    });
+  } else {
+    callArguments.push(base);
+  }
+
+  return fn.apply(null, callArguments);
+}
+
+function getFunctionArgument(obj, argument, defaultValue) {
+  const stringMatch = argument.match(stringConstantPattern);
+  if (stringMatch) {
+    return stringMatch[1];
+  }
+  return getPropertyValue(obj, argument, defaultValue);
+}
+
+function getNamedValue(obj, property) {
+  if (Array.isArray(obj)) {
+    return getArrayItem(obj, property);
+  }
+  return obj[property];
+}
+
+function getArrayItem(list, idx) {
+  if (negativeIndexPattern.test(idx)) {
+    const nidx = Number(idx);
+    const aidx = nidx === 0 ? 0 : list.length + nidx;
+    return list[aidx];
+  }
+  return list[idx];
+}
+
+module.exports = getPropertyValue;

package/node_modules/@octopus/bpmn/lib/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+exports.Engine = require('./Engine');
+exports.Definition = require('./Definition');
+exports.transformer = require('./transformer');
+exports.validation = require('./validation');

package/node_modules/@octopus/bpmn/lib/mapper.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const activityTypes = {};
+
+module.exports = function fromType(type) {
+  const activityType = activityTypes[type];
+
+  if (!activityType) {
+    throw new Error(`Unknown activity type ${type}`);
+  }
+
+  return activityType;
+};
+
+module.exports.isTask = function(type) {
+  if (!type) return false;
+  return /task$/i.test(type);
+};
+
+module.exports.Definition = activityTypes['bpmn:Definition'] = require('./Definition');
+module.exports.Process = activityTypes['bpmn:Process'] = require('./activities/BaseProcess');
+
+activityTypes['bpmn:SequenceFlow'] = require('./activities/SequenceFlow');
+activityTypes['bpmn:MessageFlow'] = require('./activities/MessageFlow');
+
+activityTypes['bpmn:IntermediateCatchEvent'] = require('./activities/IntermediateCatchEvent');
+activityTypes['bpmn:BoundaryEvent'] = require('./activities/BoundaryEvent');
+
+activityTypes['bpmn:ExclusiveGateway'] = require('./gateways/ExclusiveGateway');
+activityTypes['bpmn:ParallelGateway'] = require('./gateways/ParallelGateway');
+activityTypes['bpmn:InclusiveGateway'] = require('./gateways/InclusiveGateway');
+
+activityTypes['bpmn:ManualTask'] = require('./tasks/ManualTask');
+activityTypes['bpmn:ReceiveTask'] = require('./tasks/ReceiveTask');
+activityTypes['bpmn:SubProcess'] = require('./tasks/SubProcess');
+activityTypes['bpmn:ScriptTask'] = require('./tasks/ScriptTask');
+activityTypes['bpmn:ServiceTask'] = require('./tasks/ServiceTask');
+activityTypes['bpmn:SendTask'] = require('./tasks/SendTask');
+activityTypes['bpmn:Task'] = require('./tasks/Task');
+activityTypes['bpmn:UserTask'] = require('./tasks/UserTask');
+
+activityTypes['bpmn:StartEvent'] = require('./events/StartEvent');
+activityTypes['bpmn:EndEvent'] = require('./events/EndEvent');
+activityTypes['bpmn:TimerEventDefinition'] = require('./events/TimerEvent');
+activityTypes['bpmn:ErrorEventDefinition'] = require('./events/ErrorEvent');
+activityTypes['bpmn:MessageEventDefinition'] = require('./events/MessageEvent');
+
+activityTypes['bpmn:MultiInstanceLoopCharacteristics'] = require('./activities/MultiInstanceLoopCharacteristics');
+activityTypes['bpmn:DataObjectReference'] = require('./activities/Dummy');
+activityTypes['bpmn:DataObject'] = require('./activities/Dummy');
+
+module.exports.ActivityIO = activityTypes ['camunda:inputOutput'] = require('./activities/InputOutput');
+module.exports.ActivityProperties = activityTypes ['camunda:properties'] = require('./activities/Properties');
+module.exports.Form = activityTypes['camunda:formData'] = require('./activities/Form');
+module.exports.ServiceConnector = activityTypes['camunda:Connector'] = require('./activities/ServiceConnector');

package/node_modules/@octopus/bpmn/lib/parameter.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const debug = require('debug')('bpmn-engine:io:parameter');
+const expressions = require('./expressions');
+const scriptHelper = require('./script-helper');
+
+function Parameter(ioParm) {
+  const parm = ioParm;
+  const name = parm.name;
+  const type = parm.$type;
+  const valueType = getValueType();
+
+  debug('init', type, `<${name}>`, `as type ${valueType}`);
+
+  let script;
+  if (valueType === 'script') {
+    if (!scriptHelper.isJavascript(parm.definition.scriptFormat)) throw new Error(`Script format ${parm.definition.scriptFormat} is unsupported (${name})`);
+    script = scriptHelper.parse(`${name}.io`, parm.definition.value);
+  }
+
+  const entries = getEntries(parm);
+
+  function getValueType() {
+    if (parm.value) {
+      return expressions.hasExpression(parm.value) ? 'expression' : 'constant';
+    }
+    if (parm.definition && parm.definition.$type) {
+      return parm.definition.$type.replace('camunda:', '').toLowerCase();
+    }
+    return 'named';
+  }
+
+  function getMap(message, variablesAndServices) {
+    if (!entries) return getNamedValue(message, variablesAndServices);
+
+    return entries.reduce((result, entry) => {
+      result[entry.name] = entry.getInputValue(message, variablesAndServices);
+      return result;
+    }, {});
+  }
+
+  function getList(message, variablesAndServices) {
+    if (!entries) return getNamedValue(message, variablesAndServices);
+
+    return parm.definition.items.map((entry) => {
+      return expressions.hasExpression(entry.value) ? expressions(entry.value, Object.assign({}, message, variablesAndServices)) : entry.value;
+    }, {});
+  }
+
+  function getValue(message, variablesAndServices) {
+    debug('get', type, `<${name}>`, valueType, 'value');
+
+    switch (valueType) {
+      case 'constant':
+        return parm.value;
+      case 'expression':
+        return expressions(parm.value, Object.assign({}, variablesAndServices, message));
+      case 'script':
+        debug('execute', `<${name}>`, 'script');
+        return scriptHelper.execute(script, variablesAndServices, message);
+      case 'map':
+        return getMap(message, variablesAndServices);
+      case 'list':
+        return getList(message, variablesAndServices);
+      default:
+        return getNamedValue(message, variablesAndServices);
+    }
+  }
+
+  function getNamedValue(message, variablesAndServices) {
+    if (message && message[parm.name]) {
+      return message[parm.name];
+    }
+    if (variablesAndServices) {
+      return variablesAndServices.variables[parm.name];
+    }
+  }
+
+  function getOutputValue(resultValue, variablesAndServices) {
+    const resultType = Array.isArray(resultValue) ? 'array' : typeof resultValue;
+
+    switch (resultType) {
+      case 'object':
+      case 'function':
+        return getValue(resultValue, variablesAndServices);
+      default:
+        return getValue({
+          result: resultValue
+        }, variablesAndServices);
+    }
+  }
+
+  return {
+    name: name,
+    type: type,
+    valueType: valueType,
+    getInputValue: getValue,
+    getOutputValue: getOutputValue
+  };
+}
+
+function getEntries(parm) {
+  if (!parm.definition) return;
+
+  let entries;
+  if (parm.definition.entries) {
+    entries = parm.definition.entries.map((entry) => {
+      return Parameter(Object.assign({name: entry.key}, entry));
+    });
+  } else if (parm.definition.items) {
+    entries = parm.definition.items.map((entry, idx) => {
+      return Parameter(Object.assign({name: idx}, entry));
+    });
+  }
+
+  return entries;
+}
+
+module.exports = Parameter;

package/node_modules/@octopus/bpmn/lib/script-helper.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const vm = require('vm');
+
+const pub = {};
+
+pub.isJavascript = function(scriptType) {
+  if (!scriptType) return false;
+  return /^javascript$/i.test(scriptType);
+};
+
+pub.parse = function(filename, scriptBody) {
+  return new vm.Script(scriptBody, {
+    filename: filename,
+    displayErrors: true
+  });
+};
+
+pub.execute = function(script, context, messageOrCallback, callback) {
+  let message;
+  if (typeof messageOrCallback === 'function') {
+    callback = messageOrCallback;
+    message = {};
+  } else {
+    message = messageOrCallback;
+  }
+
+  const executionContext = Object.assign({}, message);
+  if (context) {
+    executionContext.variables = context.variables;
+    executionContext.services = context.services;
+  }
+
+  if (callback) {
+    executionContext.next = function(err, output) {
+      if (err) return callback(new Error(err.message), output);
+      callback(null, output);
+    };
+  }
+
+  const vmContext = new vm.createContext(executionContext);
+  return script.runInContext(vmContext);
+};
+
+module.exports = pub;

package/node_modules/@octopus/bpmn/lib/tasks/ManualTask.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const BaseTask = require('../activities/BaseTask');
+
+function ManualTask() {
+  BaseTask.apply(this, arguments);
+}
+
+ManualTask.prototype = Object.create(BaseTask.prototype);
+
+ManualTask.prototype.execute = function() {
+  this._debug(`<${this.id}>`, 'execute');
+  this.emit('start', this);
+  this.waiting = true;
+  this.emit('wait', this);
+};
+
+ManualTask.prototype.signal = function(input) {
+  if (!this.waiting) {
+    return this.emit('error', new Error(`<${this.id}> is not waiting`), this);
+  }
+
+  this.waiting = false;
+  this.dataOutput = input;
+  this.taken = true;
+
+  this._debug(`<${this.id}>`, 'signaled', input);
+  this.complete(input);
+};
+
+module.exports = ManualTask;

package/node_modules/@octopus/bpmn/lib/tasks/ReceiveTask.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const BaseTask = require('../activities/BaseTask');
+
+function ReceiveTask() {
+  BaseTask.apply(this, arguments);
+}
+
+ReceiveTask.prototype = Object.create(BaseTask.prototype);
+
+ReceiveTask.prototype.execute = function() {
+  this._debug(`<${this.id}>`, 'execute');
+  this.emit('start', this);
+  this.waiting = true;
+  this.emit('wait', this);
+};
+
+ReceiveTask.prototype.signal = function(input) {
+  if (!this.waiting) {
+    return this.emit('error', new Error(`<${this.id}> is not waiting`), this);
+  }
+
+  this.waiting = false;
+  this.dataOutput = input;
+  this.taken = true;
+
+  this._debug(`<${this.id}>`, 'signaled', input);
+  this.complete(input);
+};
+
+module.exports = ReceiveTask;

package/node_modules/@octopus/bpmn/lib/tasks/ScriptTask.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const BaseTask = require('../activities/BaseTask');
+const scriptHelper = require('../script-helper');
+
+function ScriptTask(activity) {
+  if (!scriptHelper.isJavascript(activity.scriptFormat)) throw new Error(`Script format ${activity.scriptFormat} is unsupported (<${activity.id}>)`);
+
+  BaseTask.apply(this, arguments);
+  this.script = scriptHelper.parse(`${this.id}.script`, this.activity.script);
+}
+
+ScriptTask.prototype = Object.create(BaseTask.prototype);
+
+ScriptTask.prototype.execute = function(message) {
+  this._debug(`<${this.id}>`, 'execute', message);
+  this.taken = true;
+  this.inboundMessage = message;
+
+  this.emit('start', this);
+
+  const input = this.getInput(message);
+
+  const executionContext = this.parentContext.getVariablesAndServices();
+  this.executeScript(executionContext, input, (err, output) => {
+    if (err) this.emit('error', err, this);
+    else this.complete(output);
+  });
+};
+
+ScriptTask.prototype.executeScript = function(variablesAndServices, messageOrCallback, callback) {
+  scriptHelper.execute(this.script, variablesAndServices, messageOrCallback, callback);
+};
+
+module.exports = ScriptTask;

package/node_modules/@octopus/bpmn/lib/tasks/SendTask.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const BaseTask = require('../activities/BaseTask');
+
+function SendTask() {
+  BaseTask.apply(this, arguments);
+}
+
+SendTask.prototype = Object.create(BaseTask.prototype);
+
+SendTask.prototype.execute = function(message) {
+  this.emit('start', this);
+  this.complete(message);
+};
+
+module.exports = SendTask;

package/node_modules/@octopus/bpmn/lib/tasks/ServiceTask.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const BaseTask = require('../activities/BaseTask');
+const expressions = require('../expressions');
+
+function ServiceTask() {
+  BaseTask.apply(this, arguments);
+  this.service = getService.call(this, this.activity, this.parentContext);
+
+  if (!this.service) throw new Error(`No service defined for <${this.id}>`);
+
+  this.resultVariable = this.activity.resultVariable;
+}
+
+ServiceTask.prototype = Object.create(BaseTask.prototype);
+
+ServiceTask.prototype.execute = function(message) {
+  this._debug(`<${this.id}>`, `execute ${this.service.name}`);
+  this.taken = true;
+  this.emit('start', this);
+
+  const scope = this;
+
+  function serviceCallback(err, serviceResult) {
+    if (err) return scope.emit('error', err, scope);
+    if (scope.resultVariable) {
+      const result = {};
+      result[scope.resultVariable] = serviceResult;
+      return scope.complete(result);
+    }
+
+    return scope.complete(serviceResult);
+  }
+
+  const input = scope.getInput(message);
+  return this.service.execute(this, input, serviceCallback);
+};
+
+ServiceTask.prototype.getInput = function(message) {
+  if (!this.io) return this.parentContext.getVariablesAndServices(message);
+  return this.io.getInput(message, true);
+};
+
+function getService(activity, parentContext) {
+  if (activity.expression) {
+    this._debug(`<${this.id}>`, `use expression ${activity.expression}`);
+    return getServiceByExpression.call(this, activity.expression);
+  }
+
+  return parentContext.getElementService(activity);
+}
+
+function getServiceByExpression(expression) {
+  return {
+    name: expression,
+    execute: (executeOnBehalfOf, message, callback) => {
+      const serviceFn = expressions(expression, executeOnBehalfOf.parentContext.getVariablesAndServices());
+      if (typeof serviceFn !== 'function') return this.emit('error', new Error(`Expression ${expression} did not resolve to a function`), this);
+
+      serviceFn(message, function(err) {
+        const args = Array.prototype.slice.call(arguments, 1);
+        callback(err, args);
+      });
+    }
+  };
+}
+
+module.exports = ServiceTask;