ghrepos 2.0.0 → 3.0.0

package/.github/dependabot.yml

@@ -0,0 +1,20 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
+    commit-message:
+      prefix: 'chore'
+      include: 'scope'
+    cooldown:
+      default-days: 5
+  - package-ecosystem: 'npm'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
+    commit-message:
+      prefix: 'chore'
+      include: 'scope'
+    cooldown:
+      default-days: 5

package/.github/workflows/test-and-release.yml

@@ -0,0 +1,56 @@
+name: Test & Maybe Release
+on: [push, pull_request]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        node: [lts/*, current]
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v6
+      - name: Use Node.js ${{ matrix.node }}
+        uses: actions/setup-node@v6
+        with:
+          node-version: ${{ matrix.node }}
+      - name: Install Dependencies
+        run: npm install --no-progress
+      - name: Check build is up to date
+        run: |
+          npm run build
+          git diff --exit-code || (echo "::error::Build artifacts not committed. Run 'npm run build' and commit the changes." && exit 1)
+      - name: Run tests
+        run: npm test
+
+  release:
+    name: Release
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: lts/*
+          registry-url: 'https://registry.npmjs.org'
+      - name: Install dependencies
+        run: npm install --no-progress --no-package-lock --no-save
+      - name: Build
+        run: npm run build
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_CONFIG_PROVENANCE: true
+        run: npx semantic-release

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+## [3.0.0](https://github.com/rvagg/ghrepos/compare/v2.1.0...v3.0.0) (2026-01-27)
+
+### ⚠ BREAKING CHANGES
+
+* modernise, ESM, promises, update deps, GHA, auto-release (#7)
+
+### Bug Fixes
+
+* add release config ([8fcbd12](https://github.com/rvagg/ghrepos/commit/8fcbd128551da685b0f227289dfe1e441b90ece1))
+
+### Trivial Changes
+
+* modernise, ESM, promises, update deps, GHA, auto-release ([#7](https://github.com/rvagg/ghrepos/issues/7)) ([8ad433d](https://github.com/rvagg/ghrepos/commit/8ad433d162b20c64f0331cdd1e2afd369027db87))

package/README.md

@@ -1,145 +1,119 @@
 # ghrepos
 
-[![Build Status](https://secure.travis-ci.org/rvagg/ghrepos.png)](http://travis-ci.org/rvagg/ghrepos)
+**A Node.js library to interact with the GitHub repos API**
 
-**A node library to interact with the GitHub repos API**
+[![NPM](https://nodei.co/npm/ghrepos.svg?style=flat&data=n,v&color=blue)](https://nodei.co/npm/ghrepos/)
 
-[![NPM](https://nodei.co/npm/ghrepos.png?mini=true)](https://nodei.co/npm/ghrepos/)
+## Requirements
 
-See also:
+- Node.js >= 20
 
-* https://github.com/rvagg/ghissues
-* https://github.com/rvagg/ghusers
-* https://github.com/rvagg/ghteams
-* https://github.com/rvagg/ghauth
+## Example usage
 
-## API
+```js
+import * as ghrepos from 'ghrepos'
 
-### listUser(auth[, user][, options], callback)
+const auth = { token: 'your-github-token' }
 
-List all repos for a user. If `user` and `options` are omitted the current user is assumed.
+// list all repos for a user
+const repos = await ghrepos.listUser(auth, 'rvagg')
+console.log(repos)
 
-List all repos for user `'rvagg'`:
+// list all repos for an org
+const orgRepos = await ghrepos.listOrg(auth, 'nodejs')
+console.log(orgRepos)
 
-```js
-const ghrepos     = require('ghrepos')
-    , authOptions = { user: 'rvagg', token: '24d5dee258c64aef38a66c0c5eca459c379901c2' }
+// get branch data
+const branch = await ghrepos.getBranch(auth, 'nodejs', 'node', 'main')
+console.log(branch)
 
-ghrepos.listUser(authOptions, 'rvagg', function (err, repolist) {
-  console.log(reposlist)
-})
+// get commit comments
+const comments = await ghrepos.getCommitComments(auth, 'nodejs', 'node', '75318e46b')
+console.log(comments)
 ```
 
-### listOrg(auth, org[, options], callback)
-
-List all repos for a organisation. If `org` and `options` are omitted the current org is assumed.
-
-List all repos for org `'nodejs'`:
+The auth data is compatible with [ghauth](https://github.com/rvagg/ghauth) so you can connect them together:
 
 ```js
-const ghrepos     = require('ghrepos')
-    , authOptions = { user: 'rvagg', token: '24d5dee258c64aef38a66c0c5eca459c379901c2' }
+import ghauth from 'ghauth'
+import * as ghrepos from 'ghrepos'
+
+const auth = await ghauth({
+  configName: 'repo-lister',
+  scopes: ['user']
+})
 
-ghrepos.listOrg(authOptions, 'nodejs', function (err, repolist) {
-  console.log(reposlist)
+const repos = await ghrepos.listUser(auth, 'rvagg')
+console.log('Repos for rvagg:')
+repos.forEach((r) => {
+  console.log('%s: %s (fork: %s)', r.name, r.description, r.fork)
 })
 ```
 
-### listRefs(auth, org, repo[, options], callback)
+## API
 
-Get git ref data for all refs in a repo.
+All methods return Promises.
 
-Get all ref data for `nodejs/io.js` repo:
+### ghrepos.listUser(auth, user, options)
 
-```js
-ghrepos.listRefs(authOptions, 'nodejs', 'io.js', function (err, refData) {
-  // data containing ref information including sha and github url
-  console.log(refData)
-})
-```
+List all repos for a user. If `user` is falsy, lists repos for the authenticated user.
 
-### listBranches(auth, org, repo[, options], callback)
+### ghrepos.listOrg(auth, org, options)
 
-Get git branch for a repo.
+List all repos for an organisation.
 
-Get all branches for `nodejs/io.js` repo:
+### ghrepos.listRefs(auth, org, repo, options)
 
-```js
-ghrepos.listBranches(authOptions, 'nodejs', 'io.js', function (err, refData) {
-  // data containing branch information including sha and github API url
-  console.log(refData)
-})
-```
+Get git ref data for all refs in a repo.
 
-### listTags(auth, org, repo[, options], callback)
+### ghrepos.listTags(auth, org, repo, options)
 
-Get git tag for a repo.
+List git tags for a repo.
 
-Get all tag for `nodejs/io.js` repo:
+### ghrepos.listBranches(auth, org, repo, options)
 
-```js
-ghrepos.listTags(authOptions, 'nodejs', 'io.js', function (err, refData) {
-  // data containing tag information including sha and github API url
-  console.log(refData)
-})
-```
+List git branches for a repo.
 
-### getRef(auth, org, repo, ref[, options], callback)
+### ghrepos.listCommits(auth, org, repo, options)
 
-Get git ref data for a particular ref string.
+List git commits for a repo.
 
-Get git ref data for `v1.x` branch in `nodejs/io.js` repo:
+### ghrepos.getRef(auth, org, repo, ref, options)
 
-```js
-ghrepos.getRef(authOptions, 'nodejs', 'io.js', 'heads/v1.x', function (err, refData) {
-  // data containing ref information including sha and github url
-  console.log(refData)
-})
-```
+Get git ref data for a particular ref string. The `refs/` prefix is automatically stripped if present.
 
-### getBranch(auth, org, repo, branch[, options], callback)
+### ghrepos.getBranch(auth, org, repo, branch, options)
 
-Get git branch data for a given branch name
+Get git branch data for a given branch name.
 
-Get git branch data for `v1.x` branch in `nodejs/io.js` repo:
+### ghrepos.getCommit(auth, org, repo, sha, options)
 
-```js
-ghrepos.getBranch(authOptions, 'nodejs', 'io.js', 'v1.x', function (err, refData) {
-  // data containing branch information including sha and github API url
-  console.log(refData)
-})
-```
+Get git commit data for a given SHA.
 
-### createLister(type)
+### ghrepos.getCommitComments(auth, org, repo, sha, options)
 
-Creates a function that lists different sub types related to the `'/repos'` api, e.g. list `'issues'`, `'pulls'` or `'releases'`. The function returned has the signature: `function list (auth, org, repo, options, callback)`.
+Get commit comments for a given SHA.
 
-_More methods coming .. as I need them or as you PR them in._
+### ghrepos.createLister(type)
 
+Creates a function that lists sub-resources under `/repos/:org/:repo/:type`, e.g. `'issues'`, `'pulls'` or `'releases'`. The returned function has the signature: `async function (auth, org, repo, options)`.
 
-The auth data is compatible with [ghauth](https://github.com/rvagg/ghauth) so you can just connect them together to make a simple command-line application:
+### ghrepos.baseUrl(org, repo, options)
 
-```js
-const ghauth     = require('ghauth')
-    , ghrepos    = require('ghrepos')
-    , authOptions = {
-          configName : 'lister'
-        , scopes     : [ 'user' ]
-      }
-
-ghauth(authOptions, function (err, authData) {
-  ghrepos.listUser(authData, 'rvagg', function (err, list) {
-    console.log('Repos for rvagg:')
-    console.log(util.inspect(list.map(function (i) { return {
-        name: i.name
-      , desc: i.description
-      , fork: i.fork
-    }})))
-  })
-})
-```
+Returns the base API URL for a repo: `https://api.github.com/repos/:org/:repo`.
+
+## Authentication
+
+See [ghauth](https://github.com/rvagg/ghauth) for an easy way to obtain and cache GitHub authentication tokens. The `auth` object returned by ghauth is directly compatible with all ghrepos methods.
+
+## See also
 
+* [ghissues](https://github.com/rvagg/ghissues) - interact with the GitHub issues API
+* [ghusers](https://github.com/rvagg/ghusers) - interact with the GitHub users API
+* [ghteams](https://github.com/rvagg/ghteams) - interact with the GitHub teams API
+* [ghpulls](https://github.com/rvagg/ghpulls) - interact with the GitHub pull requests API
+* [ghauth](https://github.com/rvagg/ghauth) - GitHub authentication
 
 ## License
 
-**ghrepos** is Copyright (c) 2015 Rod Vagg [@rvagg](https://github.com/rvagg) and licensed under the MIT licence. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.
+**ghrepos** is Copyright (c) 2014-2025 Rod Vagg [@rvagg](https://github.com/rvagg) and licensed under the MIT licence. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.

package/examples/commit-comments.js

@@ -0,0 +1,13 @@
+import ghauth from 'ghauth'
+import { getCommitComments } from '../ghrepos.js'
+
+const authData = await ghauth({
+  configName: 'lister',
+  clientId: 'your-client-id',
+  scopes: ['user']
+})
+
+const comments = await getCommitComments(authData, 'nodejs', 'node', '75318e46b')
+console.log(JSON.stringify(comments.map((i) => {
+  return { user: i.user.login, body: i.body }
+}), null, 2))

package/ghrepos.js

@@ -1,104 +1,72 @@
-const ghutils = require('ghutils')
-    , apiRoot = ghutils.apiRoot
+import { apiRoot, ghget, lister } from 'ghutils'
 
+const defaultApiUrl = apiRoot
 
-function listUser (auth, user, options, callback) {
-  return list (auth, 'user', user, options, callback)
+export function baseUrl (org, repo, options = {}) {
+  const api = options._apiUrl || defaultApiUrl
+  return `${api}/repos/${org}/${repo}`
 }
 
-
-function listOrg (auth, org, options, callback) {
-  return list (auth, 'org', org, options, callback)
+export async function listUser (auth, user, options = {}) {
+  const api = options._apiUrl || defaultApiUrl
+  const url = user ? `${api}/users/${user}/repos` : `${api}/user/repos`
+  return lister(auth, url, options)
 }
 
-
-function list (auth, type, org, options, callback) {
-  if (typeof org == 'function') { // list for this user
-    callback = org
-    options = {}
-    org = null
-  } else if (typeof options == 'function') { // no options
-    callback = options
-    options  = {}
-  }
-
-  var urlbase = apiRoot
-
-  if (org == null) {
-    urlbase += '/user/repos'
-  } else {
-    if (type == 'org')
-      urlbase += '/orgs/' + org + '/repos?'
-    else
-      urlbase += '/users/' + org + '/repos?'
-  }
-
-  ghutils.lister(auth, urlbase, options, callback)
+export async function listOrg (auth, org, options = {}) {
+  const api = options._apiUrl || defaultApiUrl
+  const url = `${api}/orgs/${org}/repos`
+  return lister(auth, url, options)
 }
 
+export async function listRefs (auth, org, repo, options = {}) {
+  const url = baseUrl(org, repo, options) + '/git/refs'
+  return lister(auth, url, options)
+}
 
-;[ 'refs', 'tags', 'branches' ].forEach(function (type) {
-  var singular = type.replace(/e?s$/, '')
-
-  var lister = function (auth, org, repo, options, callback) {
-    if (typeof options == 'function') { // no options
-      callback = options
-      options  = {}
-    }
-
-    var url = refsBaseUrl(org, repo, type)
-    ghutils.lister(auth, url, options, callback)
-  }
-
-  module.exports['list' + type[0].toUpperCase() + type.substring(1)] = lister
-
-  if (type == 'tag')
-    return
-
-  // no getTag API
-  var getter = function (auth, org, repo, ref, options, callback) {
-    if (typeof options == 'function') {
-      callback = options
-      options  = {}
-    }
-
-    // a valid ref but we're not using this format
-    ref = ref.replace(/^refs\//, '')
-
-    var url = refsBaseUrl(org, repo, type) + '/' + ref
-    ghutils.ghget(auth, url, options, callback)
-  }
-
-  module.exports['get' + singular[0].toUpperCase() + singular.substring(1)] = getter
-})
-
-
-function createLister (type) {
-  return function list (auth, org, repo, options, callback) {
-    if (typeof options == 'function') {
-      callback = options
-      options  = {}
-    }
+export async function listTags (auth, org, repo, options = {}) {
+  const url = baseUrl(org, repo, options) + '/tags'
+  return lister(auth, url, options)
+}
 
-    var url = baseUrl(org, repo) + '/' + type
-    ghutils.lister(auth, url, options, callback)
-  }
+export async function listBranches (auth, org, repo, options = {}) {
+  const url = baseUrl(org, repo, options) + '/branches'
+  return lister(auth, url, options)
 }
 
+export async function listCommits (auth, org, repo, options = {}) {
+  const url = baseUrl(org, repo, options) + '/commits'
+  return lister(auth, url, options)
+}
 
-function refsBaseUrl (org, repo, type) {
-  if (type == 'refs')
-    type = 'git/' + type
-  return baseUrl(org, repo) + '/' + type
+export async function getRef (auth, org, repo, ref, options = {}) {
+  ref = ref.replace(/^refs\//, '')
+  const url = baseUrl(org, repo, options) + '/git/refs/' + ref
+  const { data } = await ghget(auth, url, options)
+  return data
 }
 
+export async function getBranch (auth, org, repo, branch, options = {}) {
+  const url = baseUrl(org, repo, options) + '/branches/' + branch
+  const { data } = await ghget(auth, url, options)
+  return data
+}
 
-function baseUrl (org, repo) {
-  return apiRoot + '/repos/' + org + '/' + repo
+export async function getCommit (auth, org, repo, sha, options = {}) {
+  const url = baseUrl(org, repo, options) + '/commits/' + sha
+  const { data } = await ghget(auth, url, options)
+  return data
 }
 
+export async function getCommitComments (auth, org, repo, sha, options = {}) {
+  const url = baseUrl(org, repo, options) + '/commits/' + sha + '/comments'
+  const { data } = await ghget(auth, url, options)
+  return data
+}
 
-module.exports.listUser     = listUser
-module.exports.listOrg      = listOrg
-module.exports.baseUrl      = baseUrl
-module.exports.createLister = createLister
+export function createLister (type) {
+  return async function (auth, org, repo, options = {}) {
+    const url = baseUrl(org, repo, options) + '/' + type
+    return lister(auth, url, options)
+  }
+}

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "ghrepos",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Interact with the GitHub repos API",
-  "main": "ghrepos.js",
+  "type": "module",
+  "exports": "./ghrepos.js",
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
-    "test": "node test.js | faucet"
+    "lint": "standard",
+    "build": "true",
+    "test:unit": "node --test test.js",
+    "test": "npm run lint && npm run test:unit"
   },
   "repository": {
     "type": "git",
@@ -19,11 +26,98 @@
   "author": "Rod Vagg <r@va.gg>",
   "license": "MIT",
   "dependencies": {
-    "ghutils": "~3.2.0"
+    "ghutils": "^5.0.0"
   },
   "devDependencies": {
-    "faucet": "0.0.1",
-    "tape": "~4.2.2",
-    "xtend": "~4.0.0"
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.0",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.0",
+    "@semantic-release/npm": "^13.0.0",
+    "@semantic-release/release-notes-generator": "^14.0.1",
+    "conventional-changelog-conventionalcommits": "^9.0.0",
+    "semantic-release": "^25.0.0",
+    "standard": "^17.1.2"
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "chore",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
   }
 }

package/test.js

@@ -1,340 +1,252 @@
-const ghutils = require('ghutils/test-util')
-    , ghrepos = require('./')
-    , test    = require('tape')
-    , xtend   = require('xtend')
-
-
-test('test list repos for user', function (t) {
-  t.plan(10)
-
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , user     = 'testuser'
-    , testData = [
-          {
-              response : [ { test3: 'data3' }, { test4: 'data4' } ]
-            , headers  : { link: '<https://somenexturl>; rel="next"' }
-          }
-        , []
-      ]
-    , server
-
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      var result = testData[0].response
-      ghrepos.listUser(xtend(auth), user, ghutils.verifyData(t, result))
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { createMockServer, createMockServerWithHandler } from 'ghutils/test-util'
+import * as ghrepos from './ghrepos.js'
+
+test('list repos for user', async () => {
+  const auth = { token: 'test-token' }
+  const testData = [{ id: 1, name: 'repo1' }, { id: 2, name: 'repo2' }]
+
+  const server = await createMockServer({ response: testData })
+  try {
+    const results = await ghrepos.listUser(auth, 'testuser', {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/users/testuser/repos?'
-      , 'https://somenexturl'
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(results, testData)
+    assert.ok(server.requests[0].url.includes('/users/testuser/repos'))
+    assert.strictEqual(server.requests[0].headers.authorization, 'Bearer test-token')
+  } finally {
+    await server.close()
+  }
 })
 
-test('test list repos for org', function (t) {
-  t.plan(10)
+test('list repos for authed user (no user arg)', async () => {
+  const auth = { token: 'test-token' }
+  const testData = [{ id: 1, name: 'repo1' }]
 
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , org      = 'testorg'
-    , testData = [
-          {
-              response : [ { test3: 'data3' }, { test4: 'data4' } ]
-            , headers  : { link: '<https://somenexturl>; rel="next"' }
-          }
-        , []
-      ]
-    , server
-
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      var result = testData[0].response
-      ghrepos.listOrg(xtend(auth), org, ghutils.verifyData(t, result))
+  const server = await createMockServer({ response: testData })
+  try {
+    const results = await ghrepos.listUser(auth, null, {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/orgs/testorg/repos?'
-      , 'https://somenexturl'
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(results, testData)
+    assert.ok(server.requests[0].url.includes('/user/repos'))
+  } finally {
+    await server.close()
+  }
 })
 
-test('test list repos for authed user', function (t) {
-  t.plan(10)
-
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , testData = [
-          {
-              response : [ { test3: 'data3' }, { test4: 'data4' } ]
-            , headers  : { link: '<https://somenexturl>; rel="next"' }
-          }
-        , []
-      ]
-    , server
+test('list repos for org', async () => {
+  const auth = { token: 'test-token' }
+  const testData = [{ id: 1, name: 'repo1' }]
 
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      var result = testData[0].response
-      ghrepos.listUser(xtend(auth), ghutils.verifyData(t, result))
+  const server = await createMockServer({ response: testData })
+  try {
+    const results = await ghrepos.listOrg(auth, 'testorg', {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/user/repos'
-      , 'https://somenexturl'
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(results, testData)
+    assert.ok(server.requests[0].url.includes('/orgs/testorg/repos'))
+  } finally {
+    await server.close()
+  }
 })
 
-
-test('test list repos for authed user with multi-page', function (t) {
-  t.plan(13)
-
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , testData = [
-          {
-              response : [ { test3: 'data3' }, { test4: 'data4' } ]
-            , headers  : { link: '<https://somenexturl>; rel="next"' }
-          }
-        , {
-              response : [ { test5: 'data5' }, { test6: 'data6' } ]
-            , headers  : { link: '<https://somenexturl2>; rel="next"' }
-          }
-        , []
-      ]
-    , server
-
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      var result = testData[0].response.concat(testData[1].response)
-      ghrepos.listUser(xtend(auth), ghutils.verifyData(t, result))
+test('list repos with pagination', async () => {
+  const auth = { token: 'test-token' }
+  const page1 = [{ id: 1 }, { id: 2 }]
+  const page2 = [{ id: 3 }, { id: 4 }]
+
+  let requestCount = 0
+  const mock = await createMockServerWithHandler((req, res) => {
+    requestCount++
+    const port = mock.address().port
+    if (requestCount === 1) {
+      res.setHeader('link', `<http://127.0.0.1:${port}/page2>; rel="next"`)
+      res.end(JSON.stringify(page1))
+    } else {
+      res.end(JSON.stringify(page2))
+    }
+  })
+
+  try {
+    const results = await ghrepos.listUser(auth, 'testuser', {
+      _apiUrl: mock.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/user/repos'
-      , 'https://somenexturl'
-      , 'https://somenexturl2'
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(results, [...page1, ...page2])
+    assert.strictEqual(requestCount, 2)
+  } finally {
+    await mock.close()
+  }
 })
 
+test('list refs', async () => {
+  const auth = { token: 'test-token' }
+  const refs = [{ ref: 'refs/heads/main' }, { ref: 'refs/tags/v1' }]
 
-test('test list repos for authed user with no repos', function (t) {
-  t.plan(7)
-
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , testData = [ [] ]
-    , server
-
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      ghrepos.listUser(xtend(auth), ghutils.verifyData(t, []))
+  const server = await createMockServer({ response: refs })
+  try {
+    const results = await ghrepos.listRefs(auth, 'testorg', 'testrepo', {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/user/repos'
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(results, refs)
+    assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/git/refs'))
+  } finally {
+    await server.close()
+  }
 })
 
+test('list tags', async () => {
+  const auth = { token: 'test-token' }
+  const tags = [{ name: 'v1.0.0' }, { name: 'v2.0.0' }]
 
-test('test get ref list for a repo', function (t) {
-  t.plan(13)
-
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , org      = 'testorg'
-    , repo     = 'testrepo'
-    , testData = [
-          {
-              response : [ { test3: 'data3' }, { test4: 'data4' } ]
-            , headers  : { link: '<https://somenexturl>; rel="next"' }
-          }
-        , {
-              response : [ { test5: 'data5' }, { test6: 'data6' } ]
-            , headers  : { link: '<https://somenexturl2>; rel="next"' }
-          }
-        , []
-      ]
-    , server
-
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      var result = testData[0].response.concat(testData[1].response)
-      ghrepos.listRefs(xtend(auth), org, repo, ghutils.verifyData(t, result))
+  const server = await createMockServer({ response: tags })
+  try {
+    const results = await ghrepos.listTags(auth, 'testorg', 'testrepo', {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/repos/' + org + '/' + repo + '/git/refs'
-      , 'https://somenexturl'
-      , 'https://somenexturl2'
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(results, tags)
+    assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/tags'))
+  } finally {
+    await server.close()
+  }
 })
 
+test('list branches', async () => {
+  const auth = { token: 'test-token' }
+  const branches = [{ name: 'main' }, { name: 'dev' }]
 
-test('test get branch list for a repo', function (t) {
-  t.plan(13)
-
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , org      = 'testorg'
-    , repo     = 'testrepo'
-    , testData = [
-          {
-              response : [ { test3: 'data3' }, { test4: 'data4' } ]
-            , headers  : { link: '<https://somenexturl>; rel="next"' }
-          }
-        , {
-              response : [ { test5: 'data5' }, { test6: 'data6' } ]
-            , headers  : { link: '<https://somenexturl2>; rel="next"' }
-          }
-        , []
-      ]
-    , server
-
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      var result = testData[0].response.concat(testData[1].response)
-      ghrepos.listBranches(xtend(auth), org, repo, ghutils.verifyData(t, result))
+  const server = await createMockServer({ response: branches })
+  try {
+    const results = await ghrepos.listBranches(auth, 'testorg', 'testrepo', {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/repos/' + org + '/' + repo + '/branches'
-      , 'https://somenexturl'
-      , 'https://somenexturl2'
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(results, branches)
+    assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/branches'))
+  } finally {
+    await server.close()
+  }
 })
 
+test('list commits', async () => {
+  const auth = { token: 'test-token' }
+  const commits = [{ sha: 'abc123' }, { sha: 'def456' }]
 
-test('test get tag list for a repo', function (t) {
-  t.plan(13)
-
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , org      = 'testorg'
-    , repo     = 'testrepo'
-    , testData = [
-          {
-              response : [ { test3: 'data3' }, { test4: 'data4' } ]
-            , headers  : { link: '<https://somenexturl>; rel="next"' }
-          }
-        , {
-              response : [ { test5: 'data5' }, { test6: 'data6' } ]
-            , headers  : { link: '<https://somenexturl2>; rel="next"' }
-          }
-        , []
-      ]
-    , server
-
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      var result = testData[0].response.concat(testData[1].response)
-      ghrepos.listTags(xtend(auth), org, repo, ghutils.verifyData(t, result))
+  const server = await createMockServer({ response: commits })
+  try {
+    const results = await ghrepos.listCommits(auth, 'testorg', 'testrepo', {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/repos/' + org + '/' + repo + '/tags'
-      , 'https://somenexturl'
-      , 'https://somenexturl2'
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(results, commits)
+    assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/commits'))
+  } finally {
+    await server.close()
+  }
 })
 
+test('get ref', async () => {
+  const auth = { token: 'test-token' }
+  const refData = { ref: 'refs/heads/main', object: { sha: 'abc123' } }
 
-test('test get ref data for a ref', function (t) {
-  t.plan(7)
-
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , org      = 'testorg'
-    , repo     = 'testrepo'
-    , ref      = 'head/testref'
-    , testData = [
-          { test3: 'data3' }
-      ]
-    , server
-
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      ghrepos.getRef(xtend(auth), org, repo, ref, ghutils.verifyData(t, testData[0]))
+  const server = await createMockServer({ response: refData })
+  try {
+    const result = await ghrepos.getRef(auth, 'testorg', 'testrepo', 'heads/main', {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/repos/' + org + '/' + repo + '/git/refs/' + ref
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(result, refData)
+    assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/git/refs/heads/main'))
+  } finally {
+    await server.close()
+  }
 })
 
+test('get ref strips refs/ prefix', async () => {
+  const auth = { token: 'test-token' }
+  const refData = { ref: 'refs/heads/main' }
 
-test('test get branch data for a branch', function (t) {
-  t.plan(7)
+  const server = await createMockServer({ response: refData })
+  try {
+    await ghrepos.getRef(auth, 'testorg', 'testrepo', 'refs/heads/main', {
+      _apiUrl: server.baseUrl
+    })
+    assert.ok(server.requests[0].url.includes('/git/refs/heads/main'))
+    assert.ok(!server.requests[0].url.includes('/git/refs/refs/'))
+  } finally {
+    await server.close()
+  }
+})
 
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , org      = 'testorg'
-    , repo     = 'testrepo'
-    , branch   = 'testbranch'
-    , testData = [
-          { test3: 'data3' }
-      ]
-    , server
+test('get branch', async () => {
+  const auth = { token: 'test-token' }
+  const branchData = { name: 'main', commit: { sha: 'abc123' } }
 
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      ghrepos.getBranch(xtend(auth), org, repo, branch, ghutils.verifyData(t, testData[0]))
+  const server = await createMockServer({ response: branchData })
+  try {
+    const result = await ghrepos.getBranch(auth, 'testorg', 'testrepo', 'main', {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/repos/' + org + '/' + repo + '/branches/' + branch
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(result, branchData)
+    assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/branches/main'))
+  } finally {
+    await server.close()
+  }
 })
 
+test('get commit', async () => {
+  const auth = { token: 'test-token' }
+  const commitData = { sha: 'abc123', author: { login: 'testuser' } }
 
-test('test get ref data for a ref with refs/ prefix', function (t) {
-  t.plan(7)
+  const server = await createMockServer({ response: commitData })
+  try {
+    const result = await ghrepos.getCommit(auth, 'testorg', 'testrepo', 'abc123', {
+      _apiUrl: server.baseUrl
+    })
+    assert.deepStrictEqual(result, commitData)
+    assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/commits/abc123'))
+  } finally {
+    await server.close()
+  }
+})
 
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , org      = 'testorg'
-    , repo     = 'testrepo'
-    , ref      = 'head/testref'
-    , testData = [
-          { test3: 'data3' }
-      ]
-    , server
+test('get commit comments', async () => {
+  const auth = { token: 'test-token' }
+  const comments = [{ id: 1, body: 'nice' }]
 
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      ghrepos.getRef(xtend(auth), org, repo, 'refs/' + ref, ghutils.verifyData(t, testData[0]))
+  const server = await createMockServer({ response: comments })
+  try {
+    const result = await ghrepos.getCommitComments(auth, 'testorg', 'testrepo', 'abc123', {
+      _apiUrl: server.baseUrl
     })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/repos/' + org + '/' + repo + '/git/refs/' + ref
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+    assert.deepStrictEqual(result, comments)
+    assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/commits/abc123/comments'))
+  } finally {
+    await server.close()
+  }
 })
 
+test('createLister produces working lister', async () => {
+  const auth = { token: 'test-token' }
+  const data = [{ id: 1 }, { id: 2 }]
+  const customLister = ghrepos.createLister('footype')
 
-test('test footype repo lister', function (t) {
-  t.plan(10)
+  const server = await createMockServer({ response: data })
+  try {
+    const results = await customLister(auth, 'testorg', 'testrepo', {
+      _apiUrl: server.baseUrl
+    })
+    assert.deepStrictEqual(results, data)
+    assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/footype'))
+  } finally {
+    await server.close()
+  }
+})
 
-  var auth     = { user: 'authuser', token: 'authtoken' }
-    , org      = 'testorg'
-    , repo     = 'testrepo'
-    , testData = [
-          {
-              response : [ { test3: 'data3' }, { test4: 'data4' } ]
-            , headers  : { link: '<https://somenexturl>; rel="next"' }
-          }
-        , []
-      ]
-    , lister   = ghrepos.createLister('footype')
-    , server
+test('baseUrl returns correct URL', () => {
+  const url = ghrepos.baseUrl('myorg', 'myrepo')
+  assert.strictEqual(url, 'https://api.github.com/repos/myorg/myrepo')
+})
 
-  server = ghutils.makeServer(testData)
-    .on('ready', function () {
-      var result = testData[0].response
-      lister(xtend(auth), org, repo, ghutils.verifyData(t, result))
-    })
-    .on('request', ghutils.verifyRequest(t, auth))
-    .on('get', ghutils.verifyUrl(t, [
-        'https://api.github.com/repos/' + org + '/' + repo + '/footype'
-      , 'https://somenexturl'
-    ]))
-    .on('close'  , ghutils.verifyClose(t))
+test('baseUrl respects _apiUrl option', () => {
+  const url = ghrepos.baseUrl('myorg', 'myrepo', { _apiUrl: 'http://localhost:3000' })
+  assert.strictEqual(url, 'http://localhost:3000/repos/myorg/myrepo')
 })

package/.jshintrc

@@ -1,59 +0,0 @@
-{
-    "predef": [ ]
-  , "bitwise": false
-  , "camelcase": false
-  , "curly": false
-  , "eqeqeq": false
-  , "forin": false
-  , "immed": false
-  , "latedef": false
-  , "noarg": true
-  , "noempty": true
-  , "nonew": true
-  , "plusplus": false
-  , "quotmark": true
-  , "regexp": false
-  , "undef": true
-  , "unused": true
-  , "strict": false
-  , "trailing": true
-  , "maxlen": 120
-  , "asi": true
-  , "boss": true
-  , "debug": true
-  , "eqnull": true
-  , "esnext": true
-  , "evil": true
-  , "expr": true
-  , "funcscope": false
-  , "globalstrict": false
-  , "iterator": false
-  , "lastsemic": true
-  , "laxbreak": true
-  , "laxcomma": true
-  , "loopfunc": true
-  , "multistr": false
-  , "onecase": false
-  , "proto": false
-  , "regexdash": false
-  , "scripturl": true
-  , "smarttabs": false
-  , "shadow": false
-  , "sub": true
-  , "supernew": false
-  , "validthis": true
-  , "browser": true
-  , "couch": false
-  , "devel": false
-  , "dojo": false
-  , "mootools": false
-  , "node": true
-  , "nonstandard": true
-  , "prototypejs": false
-  , "rhino": false
-  , "worker": true
-  , "wsh": false
-  , "nomen": false
-  , "onevar": false
-  , "passfail": false
-}

package/.npmignore

@@ -1,2 +0,0 @@
-node_modules
-ex.js

package/.travis.yml

@@ -1,17 +0,0 @@
-language: node_js
-node_js:
-  - "5"
-  - "4"
-  - "3"
-  - "2"
-  - "1.8"
-  - "1.0"
-  - "0.12"
-  - "0.10"
-branches:
-  only:
-    - master
-notifications:
-  email:
-    - rod@vagg.org
-script: npm test