hubot 3.3.1 → 3.4.0

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)

package/src/robot.js

@@ -6,7 +6,7 @@ const path = require('path')
 
 const async = require('async')
 const Log = require('log')
-const HttpClient = require('scoped-http-client')
+const HttpClient = require('./httpclient')
 
 const Brain = require('./brain')
 const Response = require('./response')
@@ -132,7 +132,7 @@ class Robot {
     const name = this.name.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
 
     if (regexStartsWithAnchor) {
-      this.logger.warning(`Anchors don’t work well with respond, perhaps you want to use 'hear'`)
+      this.logger.warning('Anchors don’t work well with respond, perhaps you want to use \'hear\'')
       this.logger.warning(`The regex in question was ${regex.toString()}`)
     }
 
@@ -204,7 +204,7 @@ class Robot {
   invokeErrorHandlers (error, res) {
     this.logger.error(error.stack)
 
-    this.errorHandlers.map((errorHandler) => {
+    this.errorHandlers.forEach((errorHandler) => {
       try {
         errorHandler(error, res)
       } catch (errorHandlerError) {
@@ -352,7 +352,7 @@ class Robot {
     const full = path.join(filepath, path.basename(filename, ext))
 
     // see https://github.com/hubotio/hubot/issues/1355
-    if (!require.extensions[ext]) { // eslint-disable-line
+    if (['.js', '.mjs', '.coffee'].indexOf(ext) == -1) { // eslint-disable-line
       return
     }
 
@@ -429,22 +429,25 @@ class Robot {
     const paramLimit = parseInt(process.env.EXPRESS_PARAMETER_LIMIT) || 1000
 
     const express = require('express')
+    const basicAuth = require('express-basic-auth')
     const multipart = require('connect-multiparty')
 
     const app = express()
 
     app.use((req, res, next) => {
-      res.setHeader('X-Powered-By', `hubot/${this.name}`)
+      res.setHeader('X-Powered-By', `hubot/${encodeURI(this.name)}`)
       return next()
     })
 
     if (user && pass) {
-      app.use(express.basicAuth(user, pass))
+      const authUser = {}
+      authUser[user] = pass
+      app.use(basicAuth({ users: authUser }))
     }
     app.use(express.query())
 
-    app.use(express.json())
-    app.use(express.urlencoded({ limit, parameterLimit: paramLimit }))
+    app.use(express.json({ limit }))
+    app.use(express.urlencoded({ limit, parameterLimit: paramLimit, extended: true }))
     // replacement for deprecated express.multipart/connect.multipart
     // limit to 100mb, as per the old behavior
     app.use(multipart({ maxFilesSize: 100 * 1024 * 1024 }))
@@ -527,7 +530,7 @@ class Robot {
 
     const useStrictHeaderRegex = /^["']use strict['"];?\s+/
     const lines = body.replace(useStrictHeaderRegex, '').split(/(?:\n|\r\n|\r)/)
-      .reduce(toHeaderCommentBlock, {lines: [], isHeader: true}).lines
+      .reduce(toHeaderCommentBlock, { lines: [], isHeader: true }).lines
       .filter(Boolean) // remove empty lines
     let currentSection = null
     let nextSection
@@ -577,11 +580,11 @@ class Robot {
   // envelope - A Object with message, room and user details.
   // strings  - One or more Strings for each message to send.
   //
-  // Returns nothing.
+  // Returns whatever the extending adapter returns.
   send (envelope/* , ...strings */) {
     const strings = [].slice.call(arguments, 1)
 
-    this.adapter.send.apply(this.adapter, [envelope].concat(strings))
+    return this.adapter.send.apply(this.adapter, [envelope].concat(strings))
   }
 
   // Public: A helper reply function which delegates to the adapter's reply
@@ -590,11 +593,11 @@ class Robot {
   // envelope - A Object with message, room and user details.
   // strings  - One or more Strings for each message to send.
   //
-  // Returns nothing.
+  // Returns whatever the extending adapter returns.
   reply (envelope/* , ...strings */) {
     const strings = [].slice.call(arguments, 1)
 
-    this.adapter.reply.apply(this.adapter, [envelope].concat(strings))
+    return this.adapter.reply.apply(this.adapter, [envelope].concat(strings))
   }
 
   // Public: A helper send function to message a room that the robot is in.
@@ -602,12 +605,12 @@ class Robot {
   // room    - String designating the room to message.
   // strings - One or more Strings for each message to send.
   //
-  // Returns nothing.
+  // Returns whatever the extending adapter returns.
   messageRoom (room/* , ...strings */) {
     const strings = [].slice.call(arguments, 1)
     const envelope = { room }
 
-    this.adapter.send.apply(this.adapter, [envelope].concat(strings))
+    return this.adapter.send.apply(this.adapter, [envelope].concat(strings))
   }
 
   // Public: A wrapper around the EventEmitter API to make usage

package/src/user.js

@@ -18,7 +18,7 @@ class User {
     // robot itself on the user object, preventing it from
     // being serialized into the brain.
     if (options.robot) {
-      let robot = options.robot
+      const robot = options.robot
       delete options.robot
       this._getRobot = function () { return robot }
     } else {
@@ -55,7 +55,7 @@ class User {
   }
 
   _getDatastore () {
-    let robot = this._getRobot()
+    const robot = this._getRobot()
     if (robot) {
       return robot.datastore
     }

package/test/adapter_test.js

@@ -12,7 +12,7 @@ const Adapter = require('../src/adapter')
 
 describe('Adapter', function () {
   beforeEach(function () {
-    this.robot = {receive: sinon.spy()}
+    this.robot = { receive: sinon.spy() }
   })
 
   // this one is hard, as it requires files

package/test/brain_test.js

@@ -30,9 +30,9 @@ describe('Brain', function () {
 
     this.brain = new Brain(this.mockRobot)
 
-    this.user1 = this.brain.userForId('1', {name: 'Guy One'})
-    this.user2 = this.brain.userForId('2', {name: 'Guy One Two'})
-    this.user3 = this.brain.userForId('3', {name: 'Girl Three'})
+    this.user1 = this.brain.userForId('1', { name: 'Guy One' })
+    this.user2 = this.brain.userForId('2', { name: 'Guy One Two' })
+    this.user3 = this.brain.userForId('3', { name: 'Girl Three' })
   })
 
   afterEach(function () {
@@ -47,7 +47,7 @@ describe('Brain', function () {
           2: 'old'
         }
 
-        this.brain.mergeData({2: 'new'})
+        this.brain.mergeData({ 2: 'new' })
 
         expect(this.brain.data).to.deep.equal({
           1: 'old',
@@ -62,8 +62,8 @@ describe('Brain', function () {
       })
 
       it('coerces loaded data into User objects', function () {
-        this.brain.mergeData({users: {'4': {'name': 'new', 'id': '4'}}})
-        let user = this.brain.userForId('4')
+        this.brain.mergeData({ users: { 4: { name: 'new', id: '4' } } })
+        const user = this.brain.userForId('4')
         expect(user.constructor.name).to.equal('User')
         expect(user.id).to.equal('4')
         expect(user.name).to.equal('new')
@@ -213,7 +213,7 @@ describe('Brain', function () {
         })
 
         it('passes the provided options to the new User', function () {
-          const newUser = this.brain.userForId('all-new-user', {name: 'All New User', prop: 'mine'})
+          const newUser = this.brain.userForId('all-new-user', { name: 'All New User', prop: 'mine' })
           expect(newUser.name).to.equal('All New User')
           expect(newUser.prop).to.equal('mine')
         })
@@ -322,11 +322,11 @@ describe('Brain', function () {
 
     it('returns User objects, not POJOs', function () {
       expect(this.brain.userForId('1').constructor.name).to.equal('User')
-      for (let user of this.brain.usersForFuzzyName('Guy')) {
+      for (const user of this.brain.usersForFuzzyName('Guy')) {
         expect(user.constructor.name).to.equal('User')
       }
 
-      for (let user of this.brain.usersForRawFuzzyName('Guy One')) {
+      for (const user of this.brain.usersForRawFuzzyName('Guy One')) {
         expect(user.constructor.name).to.equal('User')
       }
 

package/test/datastore_test.js

@@ -26,8 +26,8 @@ describe('Datastore', function () {
 
     this.robot.brain = new Brain(this.robot)
     this.robot.datastore = new InMemoryDataStore(this.robot)
-    this.robot.brain.userForId('1', {name: 'User One'})
-    this.robot.brain.userForId('2', {name: 'User Two'})
+    this.robot.brain.userForId('1', { name: 'User One' })
+    this.robot.brain.userForId('2', { name: 'User Two' })
   })
 
   describe('global scope', function () {
@@ -46,9 +46,9 @@ describe('Datastore', function () {
     })
 
     it('can store arbitrary JavaScript values', function () {
-      let object = {
-        'name': 'test',
-        'data': [1, 2, 3]
+      const object = {
+        name: 'test',
+        data: [1, 2, 3]
       }
       return this.robot.datastore.set('key', object).then(() => {
         return this.robot.datastore.get('key').then((value) => {
@@ -59,9 +59,9 @@ describe('Datastore', function () {
     })
 
     it('can dig inside objects for values', function () {
-      let object = {
-        'a': 'one',
-        'b': 'two'
+      const object = {
+        a: 'one',
+        b: 'two'
       }
       return this.robot.datastore.set('key', object).then(() => {
         return this.robot.datastore.getObject('key', 'a').then((value) => {
@@ -71,9 +71,9 @@ describe('Datastore', function () {
     })
 
     it('can set individual keys inside objects', function () {
-      let object = {
-        'a': 'one',
-        'b': 'two'
+      const object = {
+        a: 'one',
+        b: 'two'
       }
       return this.robot.datastore.set('object', object).then(() => {
         return this.robot.datastore.setObject('object', 'c', 'three').then(() => {
@@ -89,7 +89,7 @@ describe('Datastore', function () {
     it('creates an object from scratch when none exists', function () {
       return this.robot.datastore.setObject('object', 'key', 'value').then(() => {
         return this.robot.datastore.get('object').then((value) => {
-          let expected = {'key': 'value'}
+          const expected = { key: 'value' }
           expect(value).to.deep.equal(expected)
         })
       })
@@ -116,12 +116,12 @@ describe('Datastore', function () {
 
   describe('User scope', function () {
     it('has access to the robot object', function () {
-      let user = this.robot.brain.userForId('1')
+      const user = this.robot.brain.userForId('1')
       expect(user._getRobot()).to.equal(this.robot)
     })
 
     it('can store user data which is separate from global data', function () {
-      let user = this.robot.brain.userForId('1')
+      const user = this.robot.brain.userForId('1')
       return user.set('blah', 'blah').then(() => {
         return user.get('blah').then((userBlah) => {
           return this.robot.datastore.get('blah').then((datastoreBlah) => {
@@ -134,8 +134,8 @@ describe('Datastore', function () {
     })
 
     it('stores user data separate per-user', function () {
-      let userOne = this.robot.brain.userForId('1')
-      let userTwo = this.robot.brain.userForId('2')
+      const userOne = this.robot.brain.userForId('1')
+      const userTwo = this.robot.brain.userForId('2')
       return userOne.set('blah', 'blah').then(() => {
         return userOne.get('blah').then((valueOne) => {
           return userTwo.get('blah').then((valueTwo) => {

package/test/es2015_test.js

@@ -31,7 +31,7 @@ const loadBot = Hubot.loadBot
 describe('hubot/es2015', function () {
   it('exports User class', function () {
     class MyUser extends User {}
-    const user = new MyUser('id123', {foo: 'bar'})
+    const user = new MyUser('id123', { foo: 'bar' })
 
     expect(user).to.be.an.instanceof(User)
     expect(user.id).to.equal('id123')

package/test/fixtures/mock-adapter.js

@@ -7,21 +7,26 @@ class MockAdapter extends Adapter {
     const strings = [].slice.call(arguments, 1)
     this.emit('send', envelope, strings)
   }
+
   reply (envelope/* , ...strings */) {
     const strings = [].slice.call(arguments, 1)
     this.emit('reply', envelope, strings)
   }
+
   topic (envelope/* , ...strings */) {
     const strings = [].slice.call(arguments, 1)
     this.emit('topic', envelope, strings)
   }
+
   play (envelope/* , ...strings */) {
     const strings = [].slice.call(arguments, 1)
     this.emit('play', envelope, strings)
   }
+
   run () {
     this.emit('connected')
   }
+
   close () {
     this.emit('closed')
   }

package/test/listener_test.js

@@ -303,7 +303,7 @@ describe('Listener', function () {
           const testMessage = {}
 
           const testListener = this.createListener(function () {})
-          const testMiddleware = {execute: sinon.spy()}
+          const testMiddleware = { execute: sinon.spy() }
 
           testListener.call(testMessage, result => {
             expect(testMiddleware.execute).to.not.have.been.called
@@ -334,7 +334,7 @@ describe('Listener', function () {
         const listenerCallback = sinon.spy()
         const testListener = new Listener(this.robot, testMatcher, listenerCallback)
         // slightly brittle because we are testing for the default options Object
-        expect(testListener.options).to.deep.equal({id: null})
+        expect(testListener.options).to.deep.equal({ id: null })
         expect(testListener.callback).to.be.equal(listenerCallback)
       })