reverted change to ;

Author: DavertMik

examples/fragments/Signin.js

@@ -1,9 +1,9 @@
-let I
+let I;
 
 module.exports = {
   _init() {
-    I = actor()
+    I = actor();
   },
 
   // insert your locators and methods here
-}
+};

examples/pages/Admin.js

@@ -1,9 +1,9 @@
-let I
+let I;
 
 module.exports = {
   _init() {
-    I = actor()
+    I = actor();
   },
 
   // insert your locators and methods here
-}
+};

lib/actor.js

@@ -1,11 +1,11 @@
-const Step = require('./step')
-const { MetaStep } = require('./step')
-const container = require('./container')
-const { methodsOfObject } = require('./utils')
-const recorder = require('./recorder')
-const event = require('./event')
-const store = require('./store')
-const output = require('./output')
+const Step = require('./step');
+const { MetaStep } = require('./step');
+const container = require('./container');
+const { methodsOfObject } = require('./utils');
+const recorder = require('./recorder');
+const event = require('./event');
+const store = require('./store');
+const output = require('./output');
 
 /**
  * @interface
@@ -21,13 +21,13 @@ class Actor {
    * ⚠️ returns a promise which is synchronized internally by recorder
    */
   async say(msg, color = 'cyan') {
-    const step = new Step('say', 'say')
-    step.status = 'passed'
+    const step = new Step('say', 'say');
+    step.status = 'passed';
     return recordStep(step, [msg]).then(() => {
       // this is backward compatibility as this event may be used somewhere
-      event.emit(event.step.comment, msg)
-      output.say(msg, `${color}`)
-    })
+      event.emit(event.step.comment, msg);
+      output.say(msg, `${color}`);
+    });
   }
 
   /**
@@ -38,14 +38,14 @@ class Actor {
    * @inner
    */
   limitTime(timeout) {
-    if (!store.timeouts) return this
+    if (!store.timeouts) return this;
 
     event.dispatcher.prependOnceListener(event.step.before, (step) => {
-      output.log(`Timeout to ${step}: ${timeout}s`)
-      step.setTimeout(timeout * 1000, Step.TIMEOUT_ORDER.codeLimitTime)
-    })
+      output.log(`Timeout to ${step}: ${timeout}s`);
+      step.setTimeout(timeout * 1000, Step.TIMEOUT_ORDER.codeLimitTime);
+    });
 
-    return this
+    return this;
   }
 
   /**
@@ -55,11 +55,11 @@ class Actor {
    * @inner
    */
   retry(opts) {
-    if (opts === undefined) opts = 1
-    recorder.retry(opts)
+    if (opts === undefined) opts = 1;
+    recorder.retry(opts);
     // remove retry once the step passed
-    recorder.add(() => event.dispatcher.once(event.step.finished, () => recorder.retries.pop()))
-    return this
+    recorder.add(() => event.dispatcher.once(event.step.finished, () => recorder.retries.pop()));
+    return this;
   }
 }
 
@@ -70,102 +70,102 @@ class Actor {
  * @ignore
  */
 module.exports = function (obj = {}) {
-  const actor = container.actor() || new Actor()
+  const actor = container.actor() || new Actor();
 
   // load all helpers once container initialized
   container.started(() => {
-    const translation = container.translation()
-    const helpers = container.helpers()
+    const translation = container.translation();
+    const helpers = container.helpers();
 
     // add methods from enabled helpers
     Object.values(helpers).forEach((helper) => {
       methodsOfObject(helper, 'Helper')
         .filter((method) => method !== 'constructor' && method[0] !== '_')
         .forEach((action) => {
-          const actionAlias = translation.actionAliasFor(action)
+          const actionAlias = translation.actionAliasFor(action);
           if (!actor[action]) {
             actor[action] = actor[actionAlias] = function () {
-              const step = new Step(helper, action)
+              const step = new Step(helper, action);
               if (translation.loaded) {
-                step.name = actionAlias
-                step.actor = translation.I
+                step.name = actionAlias;
+                step.actor = translation.I;
               }
               // add methods to promise chain
-              return recordStep(step, Array.from(arguments))
-            }
+              return recordStep(step, Array.from(arguments));
+            };
           }
-        })
-    })
+        });
+    });
 
     // add translated custom steps from actor
     Object.keys(obj).forEach((key) => {
-      const actionAlias = translation.actionAliasFor(key)
+      const actionAlias = translation.actionAliasFor(key);
       if (!actor[actionAlias]) {
-        actor[actionAlias] = actor[key]
+        actor[actionAlias] = actor[key];
       }
-    })
+    });
 
     container.append({
       support: {
         I: actor,
       },
-    })
-  })
+    });
+  });
   // store.actor = actor;
   // add custom steps from actor
   Object.keys(obj).forEach((key) => {
-    const ms = new MetaStep('I', key)
-    ms.setContext(actor)
-    actor[key] = ms.run.bind(ms, obj[key])
-  })
+    const ms = new MetaStep('I', key);
+    ms.setContext(actor);
+    actor[key] = ms.run.bind(ms, obj[key]);
+  });
 
-  return actor
-}
+  return actor;
+};
 
 function recordStep(step, args) {
-  step.status = 'queued'
-  step.setArguments(args)
+  step.status = 'queued';
+  step.setArguments(args);
 
   // run async before step hooks
-  event.emit(event.step.before, step)
+  event.emit(event.step.before, step);
 
-  const task = `${step.name}: ${step.humanizeArgs()}`
-  let val
+  const task = `${step.name}: ${step.humanizeArgs()}`;
+  let val;
 
   // run step inside promise
   recorder.add(
     task,
     () => {
       if (!step.startTime) {
         // step can be retries
-        event.emit(event.step.started, step)
-        step.startTime = Date.now()
+        event.emit(event.step.started, step);
+        step.startTime = Date.now();
       }
-      return (val = step.run(...args))
+      return (val = step.run(...args));
     },
     false,
     undefined,
     step.getTimeout(),
-  )
+  );
 
-  event.emit(event.step.after, step)
+  event.emit(event.step.after, step);
 
   recorder.add('step passed', () => {
-    step.endTime = Date.now()
-    event.emit(event.step.passed, step, val)
-    event.emit(event.step.finished, step)
-  })
+    step.endTime = Date.now();
+    event.emit(event.step.passed, step, val);
+    event.emit(event.step.finished, step);
+  });
 
   recorder.catchWithoutStop((err) => {
-    step.status = 'failed'
-    step.endTime = Date.now()
-    event.emit(event.step.failed, step)
-    event.emit(event.step.finished, step)
-    throw err
-  })
-
-  recorder.add('return result', () => val)
+    step.status = 'failed';
+    step.endTime = Date.now();
+    event.emit(event.step.failed, step);
+    event.emit(event.step.finished, step);
+    throw err;
+  });
+
+  recorder.add('return result', () => val);
   // run async after step hooks
 
-  return recorder.promise()
+  return recorder.promise();
 }