hubot 8.0.3 → 8.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hubot",
-  "version": "8.0.3",
+  "version": "8.1.0",
   "author": "hubot",
   "keywords": [
     "github",
@@ -15,28 +15,26 @@
     "url": "https://github.com/hubotio/hubot.git"
   },
   "dependencies": {
-    "async": "^3.2.4",
     "cline": "^0.8.2",
     "coffeescript": "^2.7.0",
     "connect-multiparty": "^2.2.0",
     "express": "^4.18.2",
     "express-basic-auth": "^1.2.1",
     "optparse": "^1.0.5",
-    "pino": "^8.11.0",
-    "standard": "^17.1.0"
+    "pino": "^8.11.0"
   },
   "devDependencies": {
     "chai": "^4.3.7",
     "is-circular": "^1.0.2",
     "mocha": "^10.2.0",
-    "mockery": "^2.1.0",
     "semantic-release": "^21.0.1",
     "sinon": "^15.0.4",
-    "sinon-chai": "^3.7.0"
+    "sinon-chai": "^3.7.0",
+    "standard": "^17.1.0"
   },
   "engines": {
-    "node": "> 4.0.0",
-    "npm": "> 2.0.0"
+    "node": "> 16.20.2",
+    "npm": "> 8.19.4"
   },
   "main": "./index",
   "bin": {

package/src/adapter.js

@@ -16,8 +16,8 @@ class Adapter extends EventEmitter {
   // envelope - A Object with message, room and user details.
   // strings  - One or more Strings for each message to send.
   //
-  // Returns nothing.
-  send (envelope/* , ...strings */) {}
+  // Returns results from adapter.
+  async send (envelope, ...strings) {}
 
   // Public: Raw method for sending emote data back to the chat source.
   // Defaults as an alias for send
@@ -25,10 +25,9 @@ class Adapter extends EventEmitter {
   // envelope - A Object with message, room and user details.
   // strings  - One or more Strings for each message to send.
   //
-  // Returns nothing.
-  emote (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-    return this.send.apply(this, [envelope].concat(strings))
+  // Returns results from adapter.
+  async emote (envelope, ...strings) {
+    return this.senda(envelope, ...strings)
   }
 
   // Public: Raw method for building a reply and sending it back to the chat
@@ -37,24 +36,24 @@ class Adapter extends EventEmitter {
   // envelope - A Object with message, room and user details.
   // strings  - One or more Strings for each reply to send.
   //
-  // Returns nothing.
-  reply (envelope/* , ...strings */) {}
+  // Returns results from adapter.
+  async reply (envelope, ...strings) {}
 
   // Public: Raw method for setting a topic on the chat source. Extend this.
   //
   // envelope - A Object with message, room and user details.
   // strings  - One more more Strings to set as the topic.
   //
-  // Returns nothing.
-  topic (envelope/* , ...strings */) {}
+  // Returns results from adapter.
+  async topic (envelope, ...strings) {}
 
   // Public: Raw method for playing a sound in the chat source. Extend this.
   //
   // envelope - A Object with message, room and user details.
   // strings  - One or more strings for each play message to send.
   //
-  // Returns nothing
-  play (envelope/* , ...strings */) {}
+  // Returns results from adapter.
+  async play (envelope, ...strings) {}
 
   // Public: Raw method for invoking the bot to run. Extend this.
   //
@@ -69,8 +68,8 @@ class Adapter extends EventEmitter {
   // Public: Dispatch a received message to the robot.
   //
   // Returns nothing.
-  receive (message) {
-    this.robot.receive(message)
+  async receive (message) {
+    await this.robot.receive(message)
   }
 
   // Public: Get an Array of User objects stored in the brain.

package/src/adapters/shell.js

@@ -22,21 +22,17 @@ class Shell extends Adapter {
     this.name = 'Shell'
   }
 
-  send (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-
+  async send (envelope, ...strings) {
     Array.from(strings).forEach(str => console.log(bold(str)))
   }
 
-  emote (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
+  async emote (envelope, ...strings) {
     Array.from(strings).map(str => this.send(envelope, `* ${str}`))
   }
 
-  reply (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1).map((s) => `${envelope.user.name}: ${s}`)
-
-    this.send.apply(this, [envelope].concat(strings))
+  async reply (envelope, ...strings) {
+    strings = strings.map((s) => `${envelope.user.name}: ${s}`)
+    this.send(envelope, ...strings)
   }
 
   run () {

package/src/listener.js

@@ -20,19 +20,19 @@ class Listener {
   constructor (robot, matcher, options, callback) {
     this.robot = robot
     this.matcher = matcher
-    this.options = options
+    this.options = options ?? {}
     this.callback = callback
 
     if (this.matcher == null) {
       throw new Error('Missing a matcher for Listener')
     }
 
-    if (this.callback == null) {
+    if (!this.callback) {
       this.callback = this.options
       this.options = {}
     }
 
-    if (this.options.id == null) {
+    if (!this.options?.id) {
       this.options.id = null
     }
 
@@ -49,60 +49,40 @@ class Listener {
   //
   // message - A Message instance.
   // middleware - Optional Middleware object to execute before the Listener callback
-  // callback - Optional Function called with a boolean of whether the matcher matched
   //
-  // Returns a boolean of whether the matcher matched.
-  // Returns before executing callback
-  call (message, middleware, didMatchCallback) {
-    // middleware argument is optional
-    if (didMatchCallback == null && typeof middleware === 'function') {
-      didMatchCallback = middleware
-      middleware = undefined
+  // Returns the result of the callback.
+  async call (message, middleware) {
+    if (middleware && typeof middleware === 'function') {
+      const fn = middleware
+      middleware = new Middleware(this.robot)
+      middleware.register(fn)
     }
 
-    // ensure we have a Middleware object
-    if (middleware == null) {
+    if (!middleware) {
       middleware = new Middleware(this.robot)
     }
 
     const match = this.matcher(message)
-    if (match) {
-      if (this.regex) {
-        this.robot.logger.debug(`Message '${message}' matched regex /${inspect(this.regex)}/; listener.options = ${inspect(this.options)}`)
-      }
-
-      // special middleware-like function that always executes the Listener's
-      // callback and calls done (never calls 'next')
-      const executeListener = (context, done) => {
-        this.robot.logger.debug(`Executing listener callback for Message '${message}'`)
-        try {
-          this.callback(context.response)
-        } catch (err) {
-          this.robot.emit('error', err, context.response)
-        }
-        done()
-      }
+    if (!match) return null
+    if (this.regex) {
+      this.robot.logger.debug(`Message '${message}' matched regex /${inspect(this.regex)}/; listener.options = ${inspect(this.options)}`)
+    }
 
-      // When everything is finished (down the middleware stack and back up),
-      // pass control back to the robot
-      const allDone = function allDone () {
-        // Yes, we tried to execute the listener callback (middleware may
-        // have intercepted before actually executing though)
-        if (didMatchCallback != null) {
-          process.nextTick(() => didMatchCallback(true))
-        }
-      }
+    const response = new this.robot.Response(this.robot, message, match)
 
-      const response = new this.robot.Response(this.robot, message, match)
-      middleware.execute({ listener: this, response }, executeListener, allDone)
-      return true
-    } else {
-      if (didMatchCallback != null) {
-        // No, we didn't try to execute the listener callback
-        process.nextTick(() => didMatchCallback(false))
-      }
-      return false
+    try {
+      const shouldContinue = await middleware.execute({ listener: this, response })
+      if (shouldContinue === false) return null
+    } catch (e) {
+      this.robot.logger.error(`Error executing middleware for listener: ${e.stack}`)
+    }
+    try {
+      return await this.callback(response)
+    } catch (e) {
+      this.robot.logger.error(`Error executing listener callback: ${e.stack}`)
+      this.robot.emit('error', e, response)
     }
+    return null
   }
 }
 

package/src/message.js

@@ -7,7 +7,7 @@ class Message {
   constructor (user, done) {
     this.user = user
     this.done = done || false
-    this.room = this.user.room
+    this.room = this.user?.room
   }
 
   // Indicates that no other Listener should be called on this object

package/src/middleware.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const async = require('async')
-
 class Middleware {
   constructor (robot) {
     this.robot = robot
@@ -16,68 +14,29 @@ class Middleware {
   // context - context object that is passed through the middleware stack.
   //     When handling errors, this is assumed to have a `response` property.
   //
-  // next(context, done) - Called when all middleware is complete (assuming
-  //     all continued by calling respective 'next' functions)
-  //
-  // done() - Initial (final) completion callback. May be wrapped by
-  //     executed middleware.
-  //
-  // Returns nothing
-  // Returns before executing any middleware
-  execute (context, next, done) {
-    const self = this
-
-    if (done == null) {
-      done = function () {}
-    }
-
-    // Execute a single piece of middleware and update the completion callback
-    // (each piece of middleware can wrap the 'done' callback with additional
-    // logic).
-    function executeSingleMiddleware (doneFunc, middlewareFunc, cb) {
-      // Match the async.reduce interface
-      function nextFunc (newDoneFunc) {
-        cb(null, newDoneFunc || doneFunc)
-      }
-
-      // Catch errors in synchronous middleware
+  // Returns bool, true | false, whether or not to continue execution
+  async execute (context) {
+    let shouldContinue = true
+    for await (const middleware of this.stack) {
       try {
-        middlewareFunc(context, nextFunc, doneFunc)
-      } catch (err) {
-        // Maintaining the existing error interface (Response object)
-        self.robot.emit('error', err, context.response)
-        // Forcibly fail the middleware and stop executing deeper
-        doneFunc()
+        shouldContinue = await middleware(context)
+        if (shouldContinue === false) break
+      } catch (e) {
+        this.robot.emit('error', e, context.response)
+        break
       }
     }
-
-    // Executed when the middleware stack is finished
-    function allDone (_, finalDoneFunc) {
-      next(context, finalDoneFunc)
-    }
-
-    // Execute each piece of middleware, collecting the latest 'done' callback
-    // at each step.
-    process.nextTick(async.reduce.bind(null, this.stack, done, executeSingleMiddleware, allDone))
+    return shouldContinue
   }
 
   // Public: Registers new middleware
   //
-  // middleware - A generic pipeline component function that can either
-  //              continue the pipeline or interrupt it. The function is called
-  //              with (robot, context, next, done). If execution should
-  //              continue (next middleware, final callback), the middleware
-  //              should call the 'next' function with 'done' as an optional
-  //              argument.
-  //              If not, the middleware should call the 'done' function with
-  //              no arguments. Middleware may wrap the 'done' function in
-  //              order to execute logic after the final callback has been
-  //              executed.
+  // middleware - Middleware function to execute prior to the listener callback. Return false to prevent execution of the listener callback.
   //
   // Returns nothing.
   register (middleware) {
-    if (middleware.length !== 3) {
-      throw new Error(`Incorrect number of arguments for middleware callback (expected 3, got ${middleware.length})`)
+    if (middleware.length !== 1) {
+      throw new Error(`Incorrect number of arguments for middleware callback (expected 1, got ${middleware.length})`)
     }
     this.stack.push(middleware)
   }

package/src/response.js

@@ -14,8 +14,7 @@ class Response {
     this.match = match
     this.envelope = {
       room: this.message.room,
-      user: this.message.user,
-      message: this.message
+      user: this.message.user
     }
   }
 
@@ -24,10 +23,9 @@ class Response {
   // strings - One or more strings to be posted. The order of these strings
   //           should be kept intact.
   //
-  // Returns nothing.
-  send (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['send', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async send (...strings) {
+    return await this.#runWithMiddleware('send', { plaintext: true }, ...strings)
   }
 
   // Public: Posts an emote back to the chat source
@@ -35,10 +33,9 @@ class Response {
   // strings - One or more strings to be posted. The order of these strings
   //           should be kept intact.
   //
-  // Returns nothing.
-  emote (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['emote', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async emote (...strings) {
+    return await this.#runWithMiddleware('emote', { plaintext: true }, ...strings)
   }
 
   // Public: Posts a message mentioning the current user.
@@ -46,10 +43,9 @@ class Response {
   // strings - One or more strings to be posted. The order of these strings
   //           should be kept intact.
   //
-  // Returns nothing.
-  reply (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['reply', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async reply (...strings) {
+    return await this.#runWithMiddleware('reply', { plaintext: true }, ...strings)
   }
 
   // Public: Posts a topic changing message
@@ -57,10 +53,9 @@ class Response {
   // strings - One or more strings to set as the topic of the
   //           room the bot is in.
   //
-  // Returns nothing.
-  topic (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['topic', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async topic (...strings) {
+    return await this.#runWithMiddleware('topic', { plaintext: true }, ...strings)
   }
 
   // Public: Play a sound in the chat source
@@ -68,10 +63,9 @@ class Response {
   // strings - One or more strings to be posted as sounds to play. The order of
   //           these strings should be kept intact.
   //
-  // Returns nothing
-  play (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['play'].concat(strings))
+  // Returns result from middleware.
+  async play (...strings) {
+    return await this.#runWithMiddleware('play', ...strings)
   }
 
   // Public: Posts a message in an unlogged room
@@ -79,27 +73,17 @@ class Response {
   // strings - One or more strings to be posted. The order of these strings
   //           should be kept intact.
   //
-  // Returns nothing
-  locked (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['locked', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async locked (...strings) {
+    await this.#runWithMiddleware('locked', { plaintext: true }, ...strings)
   }
 
-  // Private: Call with a method for the given strings using response
+  // Call with a method for the given strings using response
   // middleware.
-  runWithMiddleware (methodName, opts/* , ...strings */) {
-    const self = this
-    const strings = [].slice.call(arguments, 2)
-    const copy = strings.slice(0)
-    let callback
-
-    if (typeof copy[copy.length - 1] === 'function') {
-      callback = copy.pop()
-    }
-
+  async #runWithMiddleware (methodName, opts, ...strings) {
     const context = {
       response: this,
-      strings: copy,
+      strings,
       method: methodName
     }
 
@@ -107,17 +91,9 @@ class Response {
       context.plaintext = true
     }
 
-    function responseMiddlewareDone () {}
-    function runAdapterSend (_, done) {
-      const result = context.strings
-      if (callback != null) {
-        result.push(callback)
-      }
-      self.robot.adapter[methodName].apply(self.robot.adapter, [self.envelope].concat(result))
-      done()
-    }
-
-    return this.robot.middleware.response.execute(context, runAdapterSend, responseMiddlewareDone)
+    const shouldContinue = await this.robot.middleware.response.execute(context)
+    if (shouldContinue === false) return
+    return await this.robot.adapter[methodName](this.envelope, ...context.strings)
   }
 
   // Public: Picks a random item from the given items.

package/src/robot.js

@@ -4,7 +4,6 @@ const fs = require('fs')
 const path = require('path')
 const pathToFileURL = require('url').pathToFileURL
 
-const async = require('async')
 const pino = require('pino')
 const HttpClient = require('./httpclient')
 
@@ -244,11 +243,8 @@ class Robot {
   //
   // middleware - A function that determines whether or not a given matching
   //              Listener should be executed. The function is called with
-  //              (context, next, done). If execution should
-  //              continue (next middleware, Listener callback), the middleware
-  //              should call the 'next' function with 'done' as an argument.
-  //              If not, the middleware should call the 'done' function with
-  //              no arguments.
+  //              (context). If execution should, the middleware should return
+  //              true. If not, the middleware should return false.
   //
   // Returns nothing.
   listenerMiddleware (middleware) {
@@ -260,9 +256,8 @@ class Robot {
   //
   // middleware - A function that examines an outgoing message and can modify
   //              it or prevent its sending. The function is called with
-  //              (context, next, done). If execution should continue,
-  //              the middleware should call next(done). If execution should
-  //              stop, the middleware should call done(). To modify the
+  //              (context). If execution should continue, return true
+  //              otherwise return false to stop. To modify the
   //              outgoing message, set context.string to a new message.
   //
   // Returns nothing.
@@ -273,11 +268,10 @@ class Robot {
   // Public: Registers new middleware for execution before matching
   //
   // middleware - A function that determines whether or not listeners should be
-  //              checked. The function is called with (context, next, done). If
-  //              ext, next, done). If execution should continue to the next
-  //              middleware or matching phase, it should call the 'next'
-  //              function with 'done' as an argument. If not, the middleware
-  //              should call the 'done' function with no arguments.
+  //              checked. The function is called with (context). If execution
+  //              should continue to the next
+  //              middleware or matching phase, it should return true or nothing
+  //              otherwise return false to stop.
   //
   // Returns nothing.
   receiveMiddleware (middleware) {
@@ -290,14 +284,12 @@ class Robot {
   // message - A Message instance. Listeners can flag this message as 'done' to
   //           prevent further execution.
   //
-  // cb - Optional callback that is called when message processing is complete
-  //
-  // Returns nothing.
-  // Returns before executing callback
-  receive (message, cb) {
-    // When everything is finished (down the middleware stack and back up),
-    // pass control back to the robot
-    this.middleware.receive.execute({ response: new Response(this, message) }, this.processListeners.bind(this), cb)
+  // Returns array of results from listeners.
+  async receive (message) {
+    const context = { response: new Response(this, message) }
+    const shouldContinue = await this.middleware.receive.execute(context)
+    if (shouldContinue === false) return null
+    return await this.processListeners(context)
   }
 
   // Private: Passes the given message to any interested Listeners.
@@ -305,45 +297,40 @@ class Robot {
   // message - A Message instance. Listeners can flag this message as 'done' to
   //           prevent further execution.
   //
-  // done - Optional callback that is called when message processing is complete
-  //
-  // Returns nothing.
-  // Returns before executing callback
-  processListeners (context, done) {
+  // Returns array of results from listeners.
+  async processListeners (context) {
     // Try executing all registered Listeners in order of registration
     // and return after message is done being processed
+    const results = []
     let anyListenersExecuted = false
-
-    async.detectSeries(this.listeners, (listener, done) => {
+    for await (const listener of this.listeners) {
       try {
-        listener.call(context.response.message, this.middleware.listener, function (listenerExecuted) {
-          anyListenersExecuted = anyListenersExecuted || listenerExecuted
-          // Defer to the event loop at least after every listener so the
-          // stack doesn't get too big
-          process.nextTick(() =>
-            // Stop processing when message.done == true
-            done(null, context.response.message.done)
-          )
-        })
+        const match = listener.matcher(context.response.message)
+        if (!match) {
+          continue
+        }
+        const result = await listener.call(context.response.message, this.middleware.listener)
+        results.push(result)
+        anyListenersExecuted = true
       } catch (err) {
-        this.emit('error', err, new this.Response(this, context.response.message, []))
-        // Continue to next listener when there is an error
-        done(null, false)
+        this.emit('error', err, context)
       }
-    },
-    // Ignore the result ( == the listener that set message.done = true)
-    _ => {
-      // If no registered Listener matched the message
-
-      if (!(context.response.message instanceof Message.CatchAllMessage) && !anyListenersExecuted) {
-        this.logger.debug('No listeners executed; falling back to catch-all')
-        this.receive(new Message.CatchAllMessage(context.response.message), done)
-      } else {
-        if (done != null) {
-          process.nextTick(done)
-        }
+      if (context.response.message.done) {
+        break
       }
-    })
+    }
+
+    if (!isCatchAllMessage(context.response.message) && !anyListenersExecuted) {
+      this.logger.debug('No listeners executed; falling back to catch-all')
+      try {
+        const result = await this.receive(new Message.CatchAllMessage(context.response.message))
+        results.push(result)
+      } catch (err) {
+        this.emit('error', err, context)
+      }
+    }
+
+    return results
   }
 
   async loadmjs (filePath) {
@@ -616,10 +603,8 @@ class Robot {
   // strings  - One or more Strings for each message to send.
   //
   // Returns whatever the extending adapter returns.
-  send (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-
-    return this.adapter.send.apply(this.adapter, [envelope].concat(strings))
+  async send (envelope, ...strings) {
+    return await this.adapter.send(envelope, ...strings)
   }
 
   // Public: A helper reply function which delegates to the adapter's reply
@@ -629,10 +614,8 @@ class Robot {
   // strings  - One or more Strings for each message to send.
   //
   // Returns whatever the extending adapter returns.
-  reply (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-
-    return this.adapter.reply.apply(this.adapter, [envelope].concat(strings))
+  async reply (envelope, ...strings) {
+    return await this.adapter.reply(envelope, ...strings)
   }
 
   // Public: A helper send function to message a room that the robot is in.
@@ -641,11 +624,9 @@ class Robot {
   // strings - One or more Strings for each message to send.
   //
   // Returns whatever the extending adapter returns.
-  messageRoom (room/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
+  async messageRoom (room, ...strings) {
     const envelope = { room }
-
-    return this.adapter.send.apply(this.adapter, [envelope].concat(strings))
+    return await this.adapter.send(envelope, ...strings)
   }
 
   // Public: A wrapper around the EventEmitter API to make usage
@@ -656,10 +637,8 @@ class Robot {
   //            when event happens.
   //
   // Returns nothing.
-  on (event/* , ...args */) {
-    const args = [].slice.call(arguments, 1)
-
-    this.events.on.apply(this.events, [event].concat(args))
+  on (event, ...args) {
+    this.events.on(event, ...args)
   }
 
   // Public: A wrapper around the EventEmitter API to make usage
@@ -669,10 +648,8 @@ class Robot {
   // args...  - Arguments emitted by the event
   //
   // Returns nothing.
-  emit (event/* , ...args */) {
-    const args = [].slice.call(arguments, 1)
-
-    this.events.emit.apply(this.events, [event].concat(args))
+  emit (event, ...args) {
+    this.events.emit(event, ...args)
   }
 
   // Public: Kick off the event loop for the adapter