hubot 3.3.2 → 3.5.0

package/es2015.js

@@ -13,7 +13,7 @@ module.exports = {
   User,
   Brain,
   Robot,
-  Adapter: Adapter,
+  Adapter,
   Response,
   Listener: Listener.Listener,
   TextListener: Listener.TextListener,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hubot",
-  "version": "3.3.2",
+  "version": "3.5.0",
   "author": "hubot",
   "keywords": [
     "github",
@@ -15,27 +15,24 @@
     "url": "https://github.com/hubotio/hubot.git"
   },
   "dependencies": {
-    "async": ">=0.1.0 <1.0.0",
-    "chalk": "^1.0.0",
+    "async": "^3.2.4",
     "cline": "^0.8.2",
-    "coffeescript": "1.6.3",
-    "connect-multiparty": "^2.1.1",
-    "express": "^4.16.3",
+    "coffeescript": "^2.7.0",
+    "connect-multiparty": "^2.2.0",
+    "express": "^4.18.2",
+    "express-basic-auth": "^1.2.1",
     "log": "1.4.0",
-    "optparse": "1.0.4",
-    "scoped-http-client": "0.11.0"
+    "optparse": "^1.0.5"
   },
   "devDependencies": {
-    "chai": "~2.1.0",
-    "coveralls": "^3.0.2",
+    "chai": "^4.3.7",
     "is-circular": "^1.0.2",
-    "mocha": "^5.2.0",
-    "mockery": "^1.4.0",
-    "nyc": "^13.0.0",
-    "semantic-release": "^15.9.3",
-    "sinon": "~1.17.0",
-    "sinon-chai": "^2.8.0",
-    "standard": "^10.0.2"
+    "mocha": "^10.2.0",
+    "mockery": "^2.1.0",
+    "semantic-release": "^21.0.1",
+    "sinon": "^15.0.4",
+    "sinon-chai": "^3.7.0",
+    "standard": "^17.0.0"
   },
   "engines": {
     "node": "> 4.0.0",
@@ -48,9 +45,13 @@
   "scripts": {
     "start": "bin/hubot",
     "pretest": "standard",
-    "test": "nyc --reporter=html --reporter=text mocha",
-    "coverage": "nyc report --reporter=text-lcov | coveralls",
-    "test:smoke": "node src/**/*.js",
-    "semantic-release": "semantic-release pre && npm publish && semantic-release post"
+    "test": "mocha --exit",
+    "test:smoke": "node src/**/*.js"
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "dryRun": false
   }
 }

package/src/adapters/campfire.js

@@ -229,30 +229,30 @@ class CampfireStreaming extends EventEmitter {
       },
 
       speak (text, callback) {
-        const body = { message: { 'body': text } }
+        const body = { message: { body: text } }
         return self.post(`/room/${id}/speak`, body, callback)
       },
 
       message (text, type, callback) {
-        const body = { message: { 'body': text, 'type': type } }
+        const body = { message: { body: text, type } }
         return self.post(`/room/${id}/speak`, body, callback)
       },
 
       // listen for activity in channels
       listen () {
         const headers = {
-          'Host': 'streaming.campfirenow.com',
-          'Authorization': self.authorization,
+          Host: 'streaming.campfirenow.com',
+          Authorization: self.authorization,
           'User-Agent': `Hubot/${this.robot != null ? this.robot.version : undefined} (${this.robot != null ? this.robot.name : undefined})`
         }
 
         const options = {
-          'agent': false,
-          'host': 'streaming.campfirenow.com',
-          'port': 443,
-          'path': `/room/${id}/live.json`,
-          'method': 'GET',
-          'headers': headers
+          agent: false,
+          host: 'streaming.campfirenow.com',
+          port: 443,
+          path: `/room/${id}/live.json`,
+          method: 'GET',
+          headers
         }
 
         const request = HTTPS.request(options, function (response) {
@@ -326,19 +326,19 @@ class CampfireStreaming extends EventEmitter {
     const logger = this.robot.logger
 
     const headers = {
-      'Authorization': this.authorization,
-      'Host': this.host,
+      Authorization: this.authorization,
+      Host: this.host,
       'Content-Type': 'application/json',
       'User-Agent': `Hubot/${this.robot != null ? this.robot.version : undefined} (${this.robot != null ? this.robot.name : undefined})`
     }
 
     const options = {
-      'agent': false,
-      'host': this.host,
-      'port': 443,
-      'path': path,
-      'method': method,
-      'headers': headers
+      agent: false,
+      host: this.host,
+      port: 443,
+      path,
+      method,
+      headers
     }
 
     if (method === 'POST' || method === 'PUT') {

package/src/adapters/shell.js

@@ -4,23 +4,23 @@ const fs = require('fs')
 const readline = require('readline')
 const Stream = require('stream')
 const cline = require('cline')
-const chalk = require('chalk')
 
 const Adapter = require('../adapter')
 
-var _require = require('../message')
+const _require = require('../message')
 
 const TextMessage = _require.TextMessage
 
 const historySize = process.env.HUBOT_SHELL_HISTSIZE != null ? parseInt(process.env.HUBOT_SHELL_HISTSIZE) : 1024
 
 const historyPath = '.hubot_history'
+const bold = str => `\x1b[1m${str}\x1b[22m`
 
 class Shell extends Adapter {
   send (envelope/* , ...strings */) {
     const strings = [].slice.call(arguments, 1)
 
-    Array.from(strings).forEach(str => console.log(chalk.bold(`${str}`)))
+    Array.from(strings).forEach(str => console.log(bold(str)))
   }
 
   emote (envelope/* , ...strings */) {
@@ -36,15 +36,13 @@ class Shell extends Adapter {
 
   run () {
     this.buildCli()
-
     loadHistory((error, history) => {
       if (error) {
         console.log(error.message)
       }
-
       this.cli.history(history)
       this.cli.interact(`${this.robot.name}> `)
-      return this.emit('connected')
+      return this.emit('connected', this)
     })
   }
 
@@ -82,7 +80,7 @@ class Shell extends Adapter {
     })
 
     this.cli.on('close', () => {
-      let fileOpts, history, i, item, len, outstream, startIndex
+      let history, i, item, len
 
       history = this.cli.history()
 
@@ -90,25 +88,24 @@ class Shell extends Adapter {
         return this.shutdown()
       }
 
-      startIndex = history.length - historySize
+      const startIndex = history.length - historySize
       history = history.reverse().splice(startIndex, historySize)
-      fileOpts = {
+      const fileOpts = {
         mode: 0x180
       }
 
-      outstream = fs.createWriteStream(historyPath, fileOpts)
-      outstream.on('finish', this.shutdown.bind(this))
-
+      const outstream = fs.createWriteStream(historyPath, fileOpts)
+      outstream.on('end', this.shutdown.bind(this))
       for (i = 0, len = history.length; i < len; i++) {
         item = history[i]
         outstream.write(item + '\n')
       }
-
-      outstream.end(this.shutdown.bind(this))
     })
   }
 }
 
+// Prevent output buffer "swallowing" every other character on OSX / Node version > 16.19.0.
+process.stdout._handle.setBlocking(false)
 exports.use = robot => new Shell(robot)
 
 // load history from .hubot_history.

package/src/brain.js

@@ -10,19 +10,19 @@ const User = require('./user')
 // 2. If the original object was a User object, the original object
 // 3. If the original object was a plain JavaScript object, return
 //    a User object with all of the original object's properties.
-let reconstructUserIfNecessary = function (user, robot) {
+const reconstructUserIfNecessary = function (user, robot) {
   if (!user) {
     return null
   }
 
   if (!user.constructor || (user.constructor && user.constructor.name !== 'User')) {
-    let id = user.id
+    const id = user.id
     delete user.id
     // Use the old user as the "options" object,
     // populating the new user with its values.
     // Also add the `robot` field so it gets a reference.
     user.robot = robot
-    let newUser = new User(id, user)
+    const newUser = new User(id, user)
     delete user.robot
 
     return newUser
@@ -142,14 +142,14 @@ class Brain extends EventEmitter {
   //
   // Caveats: Deeply nested structures don't merge well.
   mergeData (data) {
-    for (let k in data || {}) {
+    for (const k in data || {}) {
       this.data[k] = data[k]
     }
 
     // Ensure users in the brain are still User objects.
     if (data && data.users) {
-      for (let k in data.users) {
-        let user = this.data.users[k]
+      for (const k in data.users) {
+        const user = this.data.users[k]
         this.data.users[k] = reconstructUserIfNecessary(user, this.getRobot())
       }
     }
@@ -195,8 +195,8 @@ class Brain extends EventEmitter {
     let result = null
     const lowerName = name.toLowerCase()
 
-    for (let k in this.data.users || {}) {
-      const userName = this.data.users[k]['name']
+    for (const k in this.data.users || {}) {
+      const userName = this.data.users[k].name
       if (userName != null && userName.toString().toLowerCase() === lowerName) {
         result = this.data.users[k]
       }

package/src/datastore.js

@@ -22,7 +22,7 @@ class DataStore {
   // present, it's instantiated as an empty object.
   setObject (key, objectKey, value) {
     return this.get(key).then((object) => {
-      let target = object || {}
+      const target = object || {}
       target[objectKey] = value
       return this.set(key, target)
     })
@@ -33,7 +33,7 @@ class DataStore {
   // present, it's instantiated as an empty array.
   setArray (key, value) {
     return this.get(key).then((object) => {
-      let target = object || []
+      const target = object || []
       // Extend the array if the value is also an array, otherwise
       // push the single value on the end.
       if (Array.isArray(value)) {
@@ -56,7 +56,7 @@ class DataStore {
   // contain an `objectKey`, returns `undefined`.
   getObject (key, objectKey) {
     return this.get(key).then((object) => {
-      let target = object || {}
+      const target = object || {}
       return target[objectKey]
     })
   }

package/src/httpclient.js

@@ -0,0 +1,312 @@
+/*
+Copyright (c) 2014 rick
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/*
+
+April 15, 2023
+Reasoning:
+ScopedHttpClient is no longer maintained.
+
+Decision:
+Implement a phased approach to deprecate `robot.http` all together in favor of `fetch`.
+1. Convert ScopedHttpClient to Javascript and include the module in this repo
+2. Add a deprecation warning to `robot.http`
+3. Remove `robot.http` in a future release
+*/
+const path = require('path')
+const http = require('http')
+const https = require('https')
+const qs = require('querystring')
+
+const nonPassThroughOptions = [
+  'headers', 'hostname', 'encoding', 'auth', 'port',
+  'protocol', 'agent', 'httpAgent', 'httpsAgent', 'query', 'host', 'path',
+  'pathname', 'slashes', 'hash'
+]
+
+class ScopedClient {
+  constructor (url, options) {
+    this.options = this.buildOptions(url, options)
+    this.passthroughOptions = reduce(extend({}, this.options), nonPassThroughOptions)
+  }
+
+  request (method, reqBody, callback) {
+    let req
+    if (typeof (reqBody) === 'function') {
+      callback = reqBody
+      reqBody = null
+    }
+
+    try {
+      let requestModule
+      const headers = extend({}, this.options.headers)
+      const sendingData = reqBody && (reqBody.length > 0)
+      headers.Host = this.options.hostname
+      if (this.options.port) { headers.Host += `:${this.options.port}` }
+
+      // If `callback` is `undefined` it means the caller isn't going to stream
+      // the body of the request using `callback` and we can set the
+      // content-length header ourselves.
+      //
+      // There is no way to conveniently assert in an else clause because the
+      // transfer encoding could be chunked or using a newer framing mechanism.
+      // And this is why we should'nt be creating a wrapper around http.
+      // Please just use `fetch`.
+      if (callback === undefined) {
+        headers['Content-Length'] = sendingData ? Buffer.byteLength(reqBody, this.options.encoding) : 0
+      }
+
+      if (this.options.auth) {
+        headers.Authorization = 'Basic ' + Buffer.from(this.options.auth, 'base64')
+      }
+
+      const port = this.options.port ||
+        ScopedClient.defaultPort[this.options.protocol] || 80
+
+      let {
+        agent
+      } = this.options
+      if (this.options.protocol === 'https:') {
+        requestModule = https
+        if (this.options.httpsAgent) { agent = this.options.httpsAgent }
+      } else {
+        requestModule = http
+        if (this.options.httpAgent) { agent = this.options.httpAgent }
+      }
+
+      const requestOptions = {
+        port,
+        host: this.options.hostname,
+        method,
+        path: this.fullPath(),
+        headers,
+        agent
+      }
+
+      // Extends the previous request options with all remaining options
+      extend(requestOptions, this.passthroughOptions)
+
+      req = requestModule.request(requestOptions)
+
+      if (this.options.timeout) {
+        req.setTimeout(this.options.timeout, () => req.abort())
+      }
+
+      if (callback) {
+        req.on('error', callback)
+      }
+      if (sendingData) { req.write(reqBody, this.options.encoding) }
+      if (callback) { callback(null, req) }
+    } catch (err) {
+      if (callback) { callback(err, req) }
+    }
+
+    return callback => {
+      if (callback) {
+        req.on('response', res => {
+          res.setEncoding(this.options.encoding)
+          let body = ''
+          res.on('data', chunk => {
+            body += chunk
+          })
+
+          return res.on('end', () => callback(null, res, body))
+        })
+        req.on('error', error => callback(error, null, null))
+      }
+
+      req.end()
+      return this
+    }
+  }
+
+  // Adds the query string to the path.
+  fullPath (p) {
+    const search = qs.stringify(this.options.query)
+    let full = this.join(p)
+    if (search.length > 0) { full += `?${search}` }
+    return full
+  }
+
+  scope (url, options, callback) {
+    const override = this.buildOptions(url, options)
+    const scoped = new ScopedClient(this.options)
+      .protocol(override.protocol)
+      .host(override.hostname)
+      .path(override.pathname)
+
+    if (typeof (url) === 'function') {
+      callback = url
+    } else if (typeof (options) === 'function') {
+      callback = options
+    }
+    if (callback) { callback(scoped) }
+    return scoped
+  }
+
+  join (suffix) {
+    const p = this.options.pathname || '/'
+    if (suffix && (suffix.length > 0)) {
+      if (suffix.match(/^\//)) {
+        return suffix
+      } else {
+        return path.join(p, suffix)
+      }
+    } else {
+      return p
+    }
+  }
+
+  path (p) {
+    this.options.pathname = this.join(p)
+    return this
+  }
+
+  query (key, value) {
+    if (!this.options.query) { this.options.query = {} }
+    if (typeof (key) === 'string') {
+      if (value) {
+        this.options.query[key] = value
+      } else {
+        delete this.options.query[key]
+      }
+    } else {
+      extend(this.options.query, key)
+    }
+    return this
+  }
+
+  host (h) {
+    if (h && (h.length > 0)) { this.options.hostname = h }
+    return this
+  }
+
+  port (p) {
+    if (p && ((typeof (p) === 'number') || (p.length > 0))) {
+      this.options.port = p
+    }
+    return this
+  }
+
+  protocol (p) {
+    if (p && (p.length > 0)) { this.options.protocol = p }
+    return this
+  }
+
+  encoding (e) {
+    if (e == null) { e = 'utf-8' }
+    this.options.encoding = e
+    return this
+  }
+
+  timeout (time) {
+    this.options.timeout = time
+    return this
+  }
+
+  auth (user, pass) {
+    if (!user) {
+      this.options.auth = null
+    } else if (!pass && user.match(/:/)) {
+      this.options.auth = user
+    } else {
+      this.options.auth = `${user}:${pass}`
+    }
+    return this
+  }
+
+  header (name, value) {
+    this.options.headers[name] = value
+    return this
+  }
+
+  headers (h) {
+    extend(this.options.headers, h)
+    return this
+  }
+
+  buildOptions () {
+    const options = {}
+    let i = 0
+    while (arguments[i]) {
+      const ty = typeof arguments[i]
+      if (ty === 'string') {
+        const parsedUrl = new URL(arguments[i])
+        const query = {}
+        parsedUrl.searchParams.forEach((v, k) => {
+          query[k] = v
+        })
+
+        extend(options, {
+          href: parsedUrl.href,
+          origin: parsedUrl.origin,
+          protocol: parsedUrl.protocol,
+          username: parsedUrl.username,
+          password: parsedUrl.password,
+          host: parsedUrl.host,
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port,
+          pathname: parsedUrl.pathname,
+          search: parsedUrl.search,
+          searchParams: parsedUrl.searchParams,
+          query,
+          hash: parsedUrl.hash
+        })
+        delete options.url
+        delete options.href
+        delete options.search
+      } else if (ty !== 'function') {
+        extend(options, arguments[i])
+      }
+      i += 1
+    }
+    if (!options.headers) { options.headers = {} }
+    if (options.encoding == null) { options.encoding = 'utf-8' }
+    return options
+  }
+}
+
+ScopedClient.methods = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE', 'HEAD']
+ScopedClient.methods.forEach(method => {
+  ScopedClient.prototype[method.toLowerCase()] = function (body, callback) { return this.request(method, body, callback) }
+})
+ScopedClient.prototype.del = ScopedClient.prototype.delete
+
+ScopedClient.defaultPort = { 'http:': 80, 'https:': 443, http: 80, https: 443 }
+
+const extend = function (a, b) {
+  Object.keys(b).forEach(prop => {
+    a[prop] = b[prop]
+  })
+  return a
+}
+
+// Removes keys specified in second parameter from first parameter
+const reduce = function (a, b) {
+  for (const propName of Array.from(b)) {
+    delete a[propName]
+  }
+  return a
+}
+
+exports.create = (url, options) => new ScopedClient(url, options)