From 1fc916c293821eafc0a4a835313c9edca19828a2 Mon Sep 17 00:00:00 2001
From: Pete Cook <pete@cookpete.com>
Date: Sun, 26 Jul 2020 20:42:49 +0100
Subject: [PATCH] Mild refactor

- Move any tag-specific logic from releases.js to tags.js
- Combine remote and latestVersion into options object to be passed around
- Use const rather than function where possible
- Hopefully fixes various bugs with single tags, including https://github.com/CookPete/auto-changelog/issues/174
---
 src/commits.js           |  36 ++++-----
 src/releases.js          | 118 ++++++++++--------------------
 src/remote.js            |   6 +-
 src/run.js               |  40 +++++-----
 src/tags.js              |  87 ++++++++++++++++------
 src/template.js          |  15 ++--
 src/utils.js             |  26 +++----
 test/commits.js          |  42 ++++++-----
 test/data/commits-map.js |   8 +-
 test/releases.js         | 140 +++++++----------------------------
 test/tags.js             | 153 +++++++++++++++++++++++++++------------
 test/template.js         |  16 ++--
 12 files changed, 336 insertions(+), 351 deletions(-)

diff --git a/src/commits.js b/src/commits.js
index 0ce106c5..b9aada39 100644
--- a/src/commits.js
+++ b/src/commits.js
@@ -18,26 +18,26 @@ const MERGE_PATTERNS = [
   /^Merge branch .+ into .+\n\n(.+)[\S\s]+See merge request [^!]*!(\d+)/ // GitLab merge
 ]
 
-async function fetchCommits (diff, remote, options = {}) {
+const fetchCommits = async (diff, options = {}) => {
   const format = await getLogFormat()
   const log = await cmd(`git log ${diff} --shortstat --pretty=format:${format} ${options.appendGitLog}`)
-  return parseCommits(log, remote, options)
+  return parseCommits(log, options)
 }
 
-async function getLogFormat () {
+const getLogFormat = async () => {
   const gitVersion = await getGitVersion()
   const bodyFormat = gitVersion && semver.gte(gitVersion, '1.7.2') ? BODY_FORMAT : FALLBACK_BODY_FORMAT
   return `${COMMIT_SEPARATOR}%H%n%ai%n%an%n%ae%n${bodyFormat}${MESSAGE_SEPARATOR}`
 }
 
-function parseCommits (string, remote, options = {}) {
+const parseCommits = (string, options = {}) => {
   return string
     .split(COMMIT_SEPARATOR)
     .slice(1)
-    .map(commit => parseCommit(commit, remote, options))
+    .map(commit => parseCommit(commit, options))
 }
 
-function parseCommit (commit, remote, options = {}) {
+const parseCommit = (commit, options = {}) => {
   const [, hash, date, author, email, tail] = commit.match(MATCH_COMMIT)
   const [body, stats] = tail.split(MESSAGE_SEPARATOR)
   const message = encodeHTML(body)
@@ -49,25 +49,25 @@ function parseCommit (commit, remote, options = {}) {
     date: new Date(date).toISOString(),
     subject: replaceText(getSubject(message), options),
     message: message.trim(),
-    fixes: getFixes(message, author, remote, options),
-    href: remote.getCommitLink(hash),
+    fixes: getFixes(message, author, options),
+    href: options.getCommitLink(hash),
     breaking: !!options.breakingPattern && new RegExp(options.breakingPattern).test(message),
     ...getStats(stats)
   }
   return {
     ...parsed,
-    merge: getMerge(parsed, message, remote, options)
+    merge: getMerge(parsed, message, options)
   }
 }
 
-function getSubject (message) {
+const getSubject = (message) => {
   if (!message) {
     return '_No commit message_'
   }
   return message.match(/[^\n]+/)[0]
 }
 
-function getStats (stats) {
+const getStats = (stats) => {
   if (!stats.trim()) return {}
   const [, files, insertions, deletions] = stats.match(MATCH_STATS)
   return {
@@ -77,21 +77,21 @@ function getStats (stats) {
   }
 }
 
-function getFixes (message, author, remote, options = {}) {
+const getFixes = (message, author, options = {}) => {
   const pattern = getFixPattern(options)
   const fixes = []
   let match = pattern.exec(message)
   if (!match) return null
   while (match) {
     const id = getFixID(match)
-    const href = isLink(match[2]) ? match[2] : remote.getIssueLink(id)
+    const href = isLink(match[2]) ? match[2] : options.getIssueLink(id)
     fixes.push({ id, href, author })
     match = pattern.exec(message)
   }
   return fixes
 }
 
-function getFixID (match) {
+const getFixID = (match) => {
   // Get the last non-falsey value in the match array
   for (let i = match.length; i >= 0; i--) {
     if (match[i]) {
@@ -100,21 +100,21 @@ function getFixID (match) {
   }
 }
 
-function getFixPattern (options) {
+const getFixPattern = (options) => {
   if (options.issuePattern) {
     return new RegExp(options.issuePattern, 'g')
   }
   return DEFAULT_FIX_PATTERN
 }
 
-function getMergePatterns (options) {
+const getMergePatterns = (options) => {
   if (options.mergePattern) {
     return MERGE_PATTERNS.concat(new RegExp(options.mergePattern, 'g'))
   }
   return MERGE_PATTERNS
 }
 
-function getMerge (commit, message, remote, options = {}) {
+const getMerge = (commit, message, options = {}) => {
   const patterns = getMergePatterns(options)
   for (const pattern of patterns) {
     const match = pattern.exec(message)
@@ -124,7 +124,7 @@ function getMerge (commit, message, remote, options = {}) {
       return {
         id,
         message: replaceText(message, options),
-        href: remote.getMergeLink(id),
+        href: options.getMergeLink(id),
         author: commit.author,
         commit
       }
diff --git a/src/releases.js b/src/releases.js
index 05392710..f835a0bc 100644
--- a/src/releases.js
+++ b/src/releases.js
@@ -1,72 +1,35 @@
 const semver = require('semver')
 const { fetchCommits } = require('./commits')
-const { niceDate } = require('./utils')
 
 const MERGE_COMMIT_PATTERN = /^Merge (remote-tracking )?branch '.+'/
 const COMMIT_MESSAGE_PATTERN = /\n+([\S\s]+)/
 
-async function createRelease (tag, previousTag, date, diff, remote, options, onParsed) {
-  const commits = await fetchCommits(diff, remote, options)
-  const merges = commits.filter(commit => commit.merge).map(commit => commit.merge)
-  const fixes = commits.filter(commit => commit.fixes).map(commit => ({ fixes: commit.fixes, commit }))
-  const emptyRelease = merges.length === 0 && fixes.length === 0
-  const { message } = commits[0] || { message: null }
-  const breakingCount = commits.filter(c => c.breaking).length
-  const filteredCommits = commits
-    .filter(commit => filterCommit(commit, options, merges))
-    .sort(commitSorter(options))
-    .slice(0, getCommitLimit(options, emptyRelease, breakingCount))
-  const release = {
-    tag,
-    title: tag || 'Unreleased',
-    date,
-    isoDate: date.slice(0, 10),
-    niceDate: niceDate(date),
-    commits: filteredCommits,
-    merges,
-    fixes,
-    summary: getSummary(message, options),
-    major: Boolean(!options.tagPattern && tag && previousTag && semver.diff(tag, previousTag) === 'major'),
-    href: getCompareLink(previousTag, tag, remote, options)
-  }
-  if (onParsed) {
-    onParsed(release)
-  }
-  return release
-}
+const parseReleases = async (tags, options, onParsed) => {
+  return Promise.all(tags.map(async tag => {
+    const commits = await fetchCommits(tag.diff, options)
+    const merges = commits.filter(commit => commit.merge).map(commit => commit.merge)
+    const fixes = commits.filter(commit => commit.fixes).map(commit => ({ fixes: commit.fixes, commit }))
+    const emptyRelease = merges.length === 0 && fixes.length === 0
+    const { message } = commits[0] || { message: null }
+    const breakingCount = commits.filter(c => c.breaking).length
+    const filteredCommits = commits
+      .filter(filterCommits(options, merges))
+      .sort(sortCommits(options))
+      .slice(0, getCommitLimit(options, emptyRelease, breakingCount))
 
-function parseReleases (tags, remote, latestVersion, options, onParsed) {
-  const releases = tags.map(({ tag, date }, index, tags) => {
-    if (tags[index - 1] && tags[index - 1].tag === options.startingVersion) {
-      return null
-    }
-    const previousTag = tags[index + 1] ? tags[index + 1].tag : null
-    const diff = previousTag ? `${previousTag}..${tag}` : tag
-    return createRelease(tag, previousTag, date, diff, remote, options, onParsed)
-  })
-  if (latestVersion || options.unreleased || options.unreleasedOnly) {
-    const tag = latestVersion || null
-    const previousTag = tags[0] ? tags[0].tag : null
-    const date = new Date().toISOString()
-    const diff = `${previousTag}..`
-    const unreleased = createRelease(tag, previousTag, date, diff, remote, options, onParsed)
-    if (options.unreleasedOnly) {
-      return Promise.all([unreleased])
-    }
-    releases.unshift(unreleased)
-  }
-  return Promise.all(releases.filter(release => release))
-}
+    if (onParsed) onParsed(tag)
 
-function getCommitLimit ({ commitLimit, backfillLimit }, emptyRelease, breakingCount) {
-  if (commitLimit === false) {
-    return undefined // Return all commits
-  }
-  const limit = emptyRelease ? backfillLimit : commitLimit
-  return Math.max(breakingCount, limit)
+    return {
+      ...tag,
+      summary: getSummary(message, options),
+      commits: filteredCommits,
+      merges,
+      fixes
+    }
+  }))
 }
 
-function filterCommit (commit, { ignoreCommitPattern }, merges) {
+const filterCommits = ({ ignoreCommitPattern }, merges) => commit => {
   if (commit.fixes || commit.merge) {
     // Filter out commits that already appear in fix or merge lists
     return false
@@ -92,33 +55,30 @@ function filterCommit (commit, { ignoreCommitPattern }, merges) {
   return true
 }
 
-function getSummary (message, { releaseSummary }) {
-  if (!message || !releaseSummary) {
-    return null
-  }
-  if (COMMIT_MESSAGE_PATTERN.test(message)) {
-    return message.match(COMMIT_MESSAGE_PATTERN)[1]
-  }
-  return null
+const sortCommits = ({ sortCommits }) => (a, b) => {
+  if (!a.breaking && b.breaking) return 1
+  if (a.breaking && !b.breaking) return -1
+  if (sortCommits === 'date') return new Date(a.date) - new Date(b.date)
+  if (sortCommits === 'date-desc') return new Date(b.date) - new Date(a.date)
+  return (b.insertions + b.deletions) - (a.insertions + a.deletions)
 }
 
-function commitSorter ({ sortCommits }) {
-  return (a, b) => {
-    if (!a.breaking && b.breaking) return 1
-    if (a.breaking && !b.breaking) return -1
-    if (sortCommits === 'date') return new Date(a.date) - new Date(b.date)
-    if (sortCommits === 'date-desc') return new Date(b.date) - new Date(a.date)
-    return (b.insertions + b.deletions) - (a.insertions + a.deletions)
+const getCommitLimit = ({ commitLimit, backfillLimit }, emptyRelease, breakingCount) => {
+  if (commitLimit === false) {
+    return undefined // Return all commits
   }
+  const limit = emptyRelease ? backfillLimit : commitLimit
+  return Math.max(breakingCount, limit)
 }
 
-function getCompareLink (previousTag, tag, remote, { tagPrefix = '' }) {
-  if (!previousTag) {
+const getSummary = (message, { releaseSummary }) => {
+  if (!message || !releaseSummary) {
     return null
   }
-  const from = `${tagPrefix}${previousTag}`
-  const to = tag ? `${tagPrefix}${tag}` : 'HEAD'
-  return remote.getCompareLink(from, to)
+  if (COMMIT_MESSAGE_PATTERN.test(message)) {
+    return message.match(COMMIT_MESSAGE_PATTERN)[1]
+  }
+  return null
 }
 
 module.exports = {
diff --git a/src/remote.js b/src/remote.js
index 877b5c25..667fd57a 100644
--- a/src/remote.js
+++ b/src/remote.js
@@ -1,12 +1,12 @@
 const parseRepoURL = require('parse-github-url')
 const { cmd } = require('./utils')
 
-async function fetchRemote (options) {
+const fetchRemote = async options => {
   const remoteURL = await cmd(`git config --get remote.${options.remote}.url`)
   return getRemote(remoteURL, options)
 }
 
-function getRemote (remoteURL, options = {}) {
+const getRemote = (remoteURL, options = {}) => {
   const overrides = getOverrides(options)
   if (!remoteURL) {
     // No point warning if everything is overridden
@@ -81,7 +81,7 @@ function getRemote (remoteURL, options = {}) {
   }
 }
 
-function getOverrides ({ commitUrl, issueUrl, mergeUrl, compareUrl }) {
+const getOverrides = ({ commitUrl, issueUrl, mergeUrl, compareUrl }) => {
   const overrides = {}
   if (commitUrl) overrides.getCommitLink = id => commitUrl.replace('{id}', id)
   if (issueUrl) overrides.getIssueLink = id => issueUrl.replace('{id}', id)
diff --git a/src/run.js b/src/run.js
index 692ed6d9..9c799eb6 100644
--- a/src/run.js
+++ b/src/run.js
@@ -23,8 +23,8 @@ const PACKAGE_FILE = 'package.json'
 const PACKAGE_OPTIONS_KEY = 'auto-changelog'
 const PREPEND_TOKEN = '<!-- auto-changelog-above -->'
 
-async function getOptions (argv) {
-  const options = new Command()
+const getOptions = async argv => {
+  const commandOptions = new Command()
     .option('-o, --output <file>', `output file, default: ${DEFAULT_OPTIONS.output}`)
     .option('-c, --config <file>', `config file location, default: ${DEFAULT_OPTIONS.config}`)
     .option('-t, --template <template>', `specify template to use [compact, keepachangelog, json], default: ${DEFAULT_OPTIONS.template}`)
@@ -58,17 +58,23 @@ async function getOptions (argv) {
 
   const pkg = await readJson(PACKAGE_FILE)
   const packageOptions = pkg ? pkg[PACKAGE_OPTIONS_KEY] : null
-  const dotOptions = await readJson(options.config || DEFAULT_OPTIONS.config)
-
-  return {
+  const dotOptions = await readJson(commandOptions.config || DEFAULT_OPTIONS.config)
+  const options = {
     ...DEFAULT_OPTIONS,
     ...dotOptions,
     ...packageOptions,
-    ...options
+    ...commandOptions
+  }
+  const remote = await fetchRemote(options)
+  const latestVersion = await getLatestVersion(options)
+  return {
+    ...options,
+    ...remote,
+    latestVersion
   }
 }
 
-async function getLatestVersion (options, tags) {
+const getLatestVersion = async options => {
   if (options.latestVersion) {
     if (!semver.valid(options.latestVersion)) {
       throw new Error('--latest-version must be a valid semver version')
@@ -81,45 +87,41 @@ async function getLatestVersion (options, tags) {
       throw new Error(`File ${file} does not exist`)
     }
     const { version } = await readJson(file)
-    const prefix = tags.some(({ tag }) => /^v/.test(tag)) ? 'v' : ''
-    return `${prefix}${version}`
+    return version
   }
   return null
 }
 
-async function run (argv) {
+const run = async argv => {
   const options = await getOptions(argv)
   const log = string => options.stdout ? null : updateLog(string)
-  log('Fetching remote…')
-  const remote = await fetchRemote(options)
   log('Fetching tags…')
   const tags = await fetchTags(options)
   log(`${tags.length} version tags found…`)
-  const latestVersion = await getLatestVersion(options, tags)
   const onParsed = ({ title }) => log(`Fetched ${title}…`)
-  const releases = await parseReleases(tags, remote, latestVersion, options, onParsed)
-  const changelog = await compileTemplate(options, { releases, options })
+  const releases = await parseReleases(tags, options, onParsed)
+  const changelog = await compileTemplate(releases, options)
   await write(changelog, options, log)
 }
 
-async function write (changelog, options, log) {
+const write = async (changelog, options, log) => {
   if (options.stdout) {
     process.stdout.write(changelog)
     return
   }
-  const bytes = Buffer.byteLength(changelog, 'utf8')
+  const bytes = formatBytes(Buffer.byteLength(changelog, 'utf8'))
   const existing = await fileExists(options.output) && await readFile(options.output, 'utf8')
   if (existing) {
     const index = options.prepend ? 0 : existing.indexOf(PREPEND_TOKEN)
     if (index !== -1) {
       const prepended = `${changelog}\n${existing.slice(index)}`
       await writeFile(options.output, prepended)
-      log(`${formatBytes(bytes)} prepended to ${options.output}\n`)
+      log(`${bytes} prepended to ${options.output}\n`)
       return
     }
   }
   await writeFile(options.output, changelog)
-  log(`${formatBytes(bytes)} written to ${options.output}\n`)
+  log(`${bytes} written to ${options.output}\n`)
 }
 
 module.exports = {
diff --git a/src/tags.js b/src/tags.js
index 435df434..fc3db039 100644
--- a/src/tags.js
+++ b/src/tags.js
@@ -1,49 +1,92 @@
 const semver = require('semver')
-const { cmd } = require('./utils')
+const { cmd, niceDate } = require('./utils')
 
 const DIVIDER = '---'
+const MATCH_V = /^v\d/
 
-async function fetchTags (options) {
-  const tags = (await cmd(`git tag -l --sort=-creatordate --format=%(refname:short)${DIVIDER}%(creatordate:short)`))
+const fetchTags = async (options, remote) => {
+  const format = `%(refname:short)${DIVIDER}%(creatordate:short)`
+  const tags = (await cmd(`git tag -l --sort=-creatordate --format=${format}`))
     .trim()
     .split('\n')
-    .map(parseTag)
+    .map(parseTag(options))
     .filter(isValidTag(options))
     .sort(sortTags(options))
-  if (options.startingVersion) {
-    const index = tags.findIndex(({ tag }) => tag === options.startingVersion)
+
+  const { latestVersion, unreleased, unreleasedOnly, getCompareLink } = options
+  if (latestVersion || unreleased || unreleasedOnly) {
+    const v = !MATCH_V.test(latestVersion) && tags.some(({ version }) => MATCH_V.test(version)) ? 'v' : ''
+    const previous = tags[0]
+    const compareTo = latestVersion ? `${v}${latestVersion}` : 'HEAD'
+    tags.unshift({
+      tag: null,
+      title: latestVersion ? `${v}${latestVersion}` : 'Unreleased',
+      date: new Date().toISOString(),
+      diff: previous ? `${previous.tag}..` : '',
+      href: previous ? getCompareLink(previous.tag, compareTo) : null
+    })
+  }
+
+  return tags
+    .map(enrichTag(options))
+    .slice(0, getLimit(tags, options))
+}
+
+const getLimit = (tags, { unreleasedOnly, startingVersion }) => {
+  if (unreleasedOnly) {
+    return 1
+  }
+  if (startingVersion) {
+    const index = tags.findIndex(({ tag }) => tag === startingVersion)
     if (index !== -1) {
-      // Leave the tag after the starting version for the diff
-      return tags.slice(0, index + 2)
+      return index + 1
     }
   }
-  return tags
+  return tags.length
 }
 
-const parseTag = string => {
+const parseTag = ({ tagPrefix }) => string => {
   const [tag, date] = string.split(DIVIDER)
-  return { tag, date }
+  return {
+    tag,
+    date,
+    title: tag,
+    version: inferSemver(tag.replace(tagPrefix, ''))
+  }
+}
+
+const enrichTag = ({ getCompareLink, tagPattern }) => (t, index, tags) => {
+  const previous = tags[index + 1]
+  return {
+    isoDate: t.date.slice(0, 10),
+    niceDate: niceDate(t.date),
+    diff: previous ? `${previous.tag}..${t.tag}` : t.tag,
+    href: previous ? getCompareLink(previous.tag, t.tag || 'HEAD') : null,
+    major: Boolean(
+      previous &&
+      semver.valid(t.version) &&
+      semver.valid(previous.version) &&
+      semver.diff(t.version, previous.version) === 'major'
+    ),
+    ...t
+  }
 }
 
-const isValidTag = ({ tagPattern, tagPrefix }) => ({ tag }) => {
+const isValidTag = ({ tagPattern }) => ({ tag, version }) => {
   if (tagPattern) {
     return new RegExp(tagPattern).test(tag)
   }
-  return semver.valid(tag.replace(tagPrefix, ''))
+  return semver.valid(version)
 }
 
-const sortTags = ({ tagPrefix }) => ({ tag: a }, { tag: b }) => {
-  const versions = {
-    a: inferSemver(a.replace(tagPrefix, '')),
-    b: inferSemver(b.replace(tagPrefix, ''))
-  }
-  if (semver.valid(versions.a) && semver.valid(versions.b)) {
-    return semver.rcompare(versions.a, versions.b)
+const sortTags = ({ tagPrefix }) => ({ version: a }, { version: b }) => {
+  if (semver.valid(a) && semver.valid(b)) {
+    return semver.rcompare(a, b)
   }
-  return a === b ? 0 : (a < b ? 1 : -1)
+  return a < b ? 1 : -1
 }
 
-function inferSemver (tag) {
+const inferSemver = tag => {
   if (/^v?\d+$/.test(tag)) {
     // v1 becomes v1.0.0
     return `${tag}.0.0`
diff --git a/src/template.js b/src/template.js
index 81265c45..a3bbe26a 100644
--- a/src/template.js
+++ b/src/template.js
@@ -9,11 +9,11 @@ const COMPILE_OPTIONS = {
   noEscape: true
 }
 
-Handlebars.registerHelper('json', function (object) {
+Handlebars.registerHelper('json', (object) => {
   return new Handlebars.SafeString(JSON.stringify(object, null, 2))
 })
 
-Handlebars.registerHelper('commit-list', function (context, options) {
+Handlebars.registerHelper('commit-list', (context, options) => {
   if (!context || context.length === 0) {
     return ''
   }
@@ -52,7 +52,7 @@ Handlebars.registerHelper('matches', function (val, pattern, options) {
   return r.test(val) ? options.fn(this) : options.inverse(this)
 })
 
-async function getTemplate (template) {
+const getTemplate = async template => {
   if (MATCH_URL.test(template)) {
     const response = await fetch(template)
     return response.text()
@@ -67,7 +67,7 @@ async function getTemplate (template) {
   return readFile(path)
 }
 
-function cleanTemplate (template) {
+const cleanTemplate = template => {
   return template
     // Remove indentation
     .replace(/\n +/g, '\n')
@@ -77,7 +77,8 @@ function cleanTemplate (template) {
     .replace(/\n\n$/, '\n')
 }
 
-async function compileTemplate ({ template, handlebarsSetup }, data) {
+const compileTemplate = async (releases, options) => {
+  const { template, handlebarsSetup } = options
   if (handlebarsSetup) {
     const setup = require(join(process.cwd(), handlebarsSetup))
     if (typeof setup === 'function') {
@@ -86,9 +87,9 @@ async function compileTemplate ({ template, handlebarsSetup }, data) {
   }
   const compile = Handlebars.compile(await getTemplate(template), COMPILE_OPTIONS)
   if (template === 'json') {
-    return compile(data)
+    return compile({ releases, options })
   }
-  return cleanTemplate(compile(data))
+  return cleanTemplate(compile({ releases, options }))
 }
 
 module.exports = {
diff --git a/src/utils.js b/src/utils.js
index 85fdd58a..7fd934f6 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -4,7 +4,7 @@ const { spawn } = require('child_process')
 
 const MONTH_NAMES = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
 
-function updateLog (string, clearLine = true) {
+const updateLog = (string, clearLine = true) => {
   if (clearLine) {
     readline.clearLine(process.stdout)
     readline.cursorTo(process.stdout, 0)
@@ -12,12 +12,12 @@ function updateLog (string, clearLine = true) {
   process.stdout.write(`auto-changelog: ${string}`)
 }
 
-function formatBytes (bytes) {
+const formatBytes = (bytes) => {
   return `${Math.max(1, Math.round(bytes / 1024))} kB`
 }
 
 // Simple util for calling a child process
-function cmd (string, onProgress) {
+const cmd = (string, onProgress) => {
   const [cmd, ...args] = string.trim().split(' ')
   return new Promise((resolve, reject) => {
     const child = spawn(cmd, args)
@@ -34,13 +34,13 @@ function cmd (string, onProgress) {
   })
 }
 
-async function getGitVersion () {
+const getGitVersion = async () => {
   const output = await cmd('git --version')
   const match = output.match(/\d+\.\d+\.\d+/)
   return match ? match[0] : null
 }
 
-function niceDate (string) {
+const niceDate = (string) => {
   const date = new Date(string)
   const day = date.getUTCDate()
   const month = MONTH_NAMES[date.getUTCMonth()]
@@ -48,19 +48,19 @@ function niceDate (string) {
   return `${day} ${month} ${year}`
 }
 
-function isLink (string) {
+const isLink = (string) => {
   return /^http/.test(string)
 }
 
-function parseLimit (limit) {
+const parseLimit = (limit) => {
   return limit === 'false' ? false : parseInt(limit, 10)
 }
 
-function encodeHTML (string) {
+const encodeHTML = (string) => {
   return string.replace(/</g, '&lt;').replace(/>/g, '&gt;')
 }
 
-function replaceText (string, options) {
+const replaceText = (string, options) => {
   if (!options.replaceText) {
     return string
   }
@@ -74,25 +74,25 @@ const createCallback = (resolve, reject) => (err, data) => {
   else resolve(data)
 }
 
-function readFile (path) {
+const readFile = (path) => {
   return new Promise((resolve, reject) => {
     fs.readFile(path, 'utf-8', createCallback(resolve, reject))
   })
 }
 
-function writeFile (path, data) {
+const writeFile = (path, data) => {
   return new Promise((resolve, reject) => {
     fs.writeFile(path, data, createCallback(resolve, reject))
   })
 }
 
-function fileExists (path) {
+const fileExists = (path) => {
   return new Promise(resolve => {
     fs.access(path, err => resolve(!err))
   })
 }
 
-async function readJson (path) {
+const readJson = async (path) => {
   if (await fileExists(path) === false) {
     return null
   }
diff --git a/test/commits.js b/test/commits.js
index bf3fdf9d..8c23456f 100644
--- a/test/commits.js
+++ b/test/commits.js
@@ -18,15 +18,11 @@ const getMerge = __get__('getMerge')
 const getSubject = __get__('getSubject')
 const getLogFormat = __get__('getLogFormat')
 
-const options = {
-  tagPrefix: ''
-}
-
 describe('fetchCommits', () => {
   it('fetches commits', async () => {
     const gitLog = await readFile(join(__dirname, 'data', 'git-log.txt'))
     mock('cmd', () => gitLog)
-    expect(await fetchCommits('', remotes.github, options)).to.deep.equal(commits)
+    expect(await fetchCommits('', remotes.github)).to.deep.equal(commits)
     unmock('cmd')
   })
 })
@@ -34,12 +30,12 @@ describe('fetchCommits', () => {
 describe('parseCommits', () => {
   it('parses commits', async () => {
     const gitLog = await readFile(join(__dirname, 'data', 'git-log.txt'))
-    expect(parseCommits(gitLog, remotes.github, options)).to.deep.equal(commits)
+    expect(parseCommits(gitLog, remotes.github)).to.deep.equal(commits)
   })
 
   it('parses commits without remote', async () => {
     const gitLog = await readFile(join(__dirname, 'data', 'git-log.txt'))
-    expect(parseCommits(gitLog, remotes.null, options)).to.deep.equal(commitsNoRemote)
+    expect(parseCommits(gitLog, remotes.null)).to.deep.equal(commitsNoRemote)
   })
 
   it('parses bitbucket commits', async () => {
@@ -50,8 +46,11 @@ describe('parseCommits', () => {
 
   it('supports breakingPattern option', async () => {
     const gitLog = await readFile(join(__dirname, 'data', 'git-log.txt'))
-    const options = { breakingPattern: 'Some breaking change' }
-    const result = parseCommits(gitLog, remotes.github, options)
+    const options = {
+      breakingPattern: 'Some breaking change',
+      ...remotes.github
+    }
+    const result = parseCommits(gitLog, options)
     expect(result.filter(c => c.breaking)).to.have.length(1)
   })
 
@@ -60,9 +59,10 @@ describe('parseCommits', () => {
     const options = {
       replaceText: {
         breaking: '**BREAKING**'
-      }
+      },
+      ...remotes.github
     }
-    const result = parseCommits(gitLog, remotes.github, options)
+    const result = parseCommits(gitLog, options)
     expect(result.filter(c => c.subject === 'Some **BREAKING** change')).to.have.length(1)
   })
 })
@@ -142,20 +142,22 @@ describe('getFixes', () => {
 
   it('supports issuePattern parameter', () => {
     const options = {
-      issuePattern: '[A-Z]+-\\d+'
+      issuePattern: '[A-Z]+-\\d+',
+      ...remotes.github
     }
     const message = 'Commit message\n\nCloses ABC-1234'
-    expect(getFixes(message, 'Commit Author', remotes.github, options)).to.deep.equal([
+    expect(getFixes(message, 'Commit Author', options)).to.deep.equal([
       { id: 'ABC-1234', href: 'https://github.com/user/repo/issues/ABC-1234', author: 'Commit Author' }
     ])
   })
 
   it('supports issuePattern parameter with capture group', () => {
     const options = {
-      issuePattern: '[Ff]ixes ([A-Z]+-\\d+)'
+      issuePattern: '[Ff]ixes ([A-Z]+-\\d+)',
+      ...remotes.github
     }
     const message = 'Commit message\n\nFixes ABC-1234 and fixes ABC-2345 but not BCD-2345'
-    expect(getFixes(message, 'Commit Author', remotes.github, options)).to.deep.equal([
+    expect(getFixes(message, 'Commit Author', options)).to.deep.equal([
       { id: 'ABC-1234', href: 'https://github.com/user/repo/issues/ABC-1234', author: 'Commit Author' },
       { id: 'ABC-2345', href: 'https://github.com/user/repo/issues/ABC-2345', author: 'Commit Author' }
     ])
@@ -275,11 +277,12 @@ describe('getMerge', () => {
 
   it('supports mergePattern parameter', () => {
     const options = {
-      mergePattern: 'PR #(\\d+) from .+\\n\\n.+\\n(.+)'
+      mergePattern: 'PR #(\\d+) from .+\\n\\n.+\\n(.+)',
+      ...remotes.github
     }
 
     const message = 'PR #37 from repo/branch\n\ncommit sha512\nPull request title'
-    expect(getMerge(EXAMPLE_COMMIT, message, remotes.github, options)).to.deep.equal({
+    expect(getMerge(EXAMPLE_COMMIT, message, options)).to.deep.equal({
       id: '37',
       message: 'Pull request title',
       href: 'https://github.com/user/repo/pull/37',
@@ -293,9 +296,10 @@ describe('getMerge', () => {
     const options = {
       replaceText: {
         '(..l)': '_$1_'
-      }
+      },
+      ...remotes.github
     }
-    expect(getMerge(EXAMPLE_COMMIT, message, remotes.github, options)).to.deep.equal({
+    expect(getMerge(EXAMPLE_COMMIT, message, options)).to.deep.equal({
       id: '3',
       message: '_Pul_l request t_itl_e',
       href: 'https://github.com/user/repo/pull/3',
diff --git a/test/data/commits-map.js b/test/data/commits-map.js
index f04fd046..87a5ccbc 100644
--- a/test/data/commits-map.js
+++ b/test/data/commits-map.js
@@ -1,10 +1,10 @@
 const { generateCommits } = require('../utils/commits')
 
 const tags = [
-  { tag: 'v1.0.0', date: '2015-12-15T12:03:09.000Z' },
-  { tag: 'v0.1.0', date: '2015-12-29T21:19:17.000Z' },
-  { tag: 'v0.0.2', date: '2015-12-28T21:17:17.000Z' },
-  { tag: 'v0.0.1', date: '2015-12-15T12:03:09.000Z' }
+  { tag: 'v1.0.0', date: '2015-12-15T12:03:09.000Z', diff: 'v0.1.0..v1.0.0', major: true },
+  { tag: 'v0.1.0', date: '2015-12-29T21:19:17.000Z', diff: 'v0.0.2..v0.1.0' },
+  { tag: 'v0.0.2', date: '2015-12-28T21:17:17.000Z', diff: 'v0.0.1..v0.0.2' },
+  { tag: 'v0.0.1', date: '2015-12-15T12:03:09.000Z', diff: 'v0.0.1' }
 ]
 
 const commitsMap = {
diff --git a/test/releases.js b/test/releases.js
index 3ab45be5..e8009503 100644
--- a/test/releases.js
+++ b/test/releases.js
@@ -1,9 +1,6 @@
-const { describe, it, beforeEach, afterEach } = require('mocha')
+const { describe, it, afterEach } = require('mocha')
 const { expect } = require('chai')
 const remotes = require('./data/remotes')
-const { tags, commitsMap } = require('./data/commits-map')
-const commitsSingleRelease = require('./data/commits-single-release')
-const releases = require('./data/releases')
 const { generateCommits } = require('./utils/commits')
 const {
   parseReleases,
@@ -33,13 +30,27 @@ describe('parseReleases', () => {
     const options = {
       commitLimit: 3,
       backfillLimit: 3,
-      tagPrefix: ''
+      tagPrefix: '',
+      latestVersion: null,
+      ...remotes.github
     }
     const tags = [
-      { tag: 'v2.0.0', date: '2000-01-01' },
-      { tag: 'v1.0.0', date: '2000-01-01' }
+      {
+        tag: 'v2.0.0',
+        date: '2000-01-01',
+        diff: 'v1.0.0..v2.0.0',
+        major: true,
+        href: 'https://github.com/user/repo/compare/v1.0.0...v2.0.0'
+      },
+      {
+        tag: 'v1.0.0',
+        date: '2000-01-01',
+        diff: 'v1.0.0',
+        major: false,
+        href: null
+      }
     ]
-    const releases = await parseReleases(tags, remotes.github, null, options)
+    const releases = await parseReleases(tags, options)
     expect(releases).to.be.an('array')
     expect(releases[0]).to.include({
       tag: 'v2.0.0',
@@ -63,8 +74,8 @@ describe('parseReleases', () => {
     }
     mock('fetchCommits', diff => Promise.resolve(map[diff]))
     const options = { commitLimit: 1 }
-    const tags = [{ tag: 'v1.0.0', date: '2000-01-01' }]
-    const releases = await parseReleases(tags, remotes.github, null, options)
+    const tags = [{ tag: 'v1.0.0', date: '2000-01-01', diff: 'v1.0.0' }]
+    const releases = await parseReleases(tags, options)
     expect(releases[0].commits).to.have.lengthOf(1)
     expect(releases[0].commits[0]).to.include({ subject: 'Second commit' })
   })
@@ -75,8 +86,8 @@ describe('parseReleases', () => {
     }
     mock('fetchCommits', diff => Promise.resolve(map[diff]))
     const options = { commitLimit: false }
-    const tags = [{ tag: 'v1.0.0', date: '2000-01-01' }]
-    const releases = await parseReleases(tags, remotes.github, null, options)
+    const tags = [{ tag: 'v1.0.0', date: '2000-01-01', diff: 'v1.0.0' }]
+    const releases = await parseReleases(tags, options)
     expect(releases[0].commits).to.have.lengthOf(4)
   })
 
@@ -86,8 +97,8 @@ describe('parseReleases', () => {
     }
     mock('fetchCommits', diff => Promise.resolve(map[diff]))
     const options = { backfillLimit: 1 }
-    const tags = [{ tag: 'v1.0.0', date: '2000-01-01' }]
-    const releases = await parseReleases(tags, remotes.github, null, options)
+    const tags = [{ tag: 'v1.0.0', date: '2000-01-01', diff: 'v1.0.0' }]
+    const releases = await parseReleases(tags, options)
     expect(releases[0].commits).to.have.lengthOf(1)
     expect(releases[0].commits[0]).to.include({ subject: 'Second commit' })
   })
@@ -101,106 +112,9 @@ describe('parseReleases', () => {
     }
     mock('fetchCommits', diff => Promise.resolve(map[diff]))
     const options = { commitLimit: 0, backfillLimit: 0 }
-    const tags = [{ tag: 'v1.0.0', date: '2000-01-01' }]
-    const releases = await parseReleases(tags, remotes.github, null, options)
+    const tags = [{ tag: 'v1.0.0', date: '2000-01-01', diff: 'v1.0.0' }]
+    const releases = await parseReleases(tags, options)
     expect(releases[0].commits).to.have.lengthOf(1)
     expect(releases[0].commits[0]).to.include({ subject: 'First commit' })
   })
 })
-
-const options = {
-  unreleased: false,
-  commitLimit: 3,
-  backfillLimit: 3,
-  tagPrefix: '',
-  sortCommits: 'relevance'
-}
-
-describe('parseReleases (legacy)', () => {
-  beforeEach(() => {
-    mock('fetchCommits', diff => Promise.resolve(commitsMap[diff]))
-  })
-
-  afterEach(() => {
-    unmock('fetchCommits')
-  })
-
-  it('parses releases', async () => {
-    expect(await parseReleases(tags, remotes.github, null, options)).to.deep.equal(releases)
-  })
-
-  it('parses releases with no commit limit', async () => {
-    expect(await parseReleases(tags, remotes.github, null, { ...options, commitLimit: false })).to.deep.equal(releases)
-  })
-
-  it('parses releases with backfill limit', async () => {
-    const releases = await parseReleases(tags, remotes.github, null, {
-      ...options,
-      commitLimit: 0,
-      backfillLimit: 1
-    })
-    for (const release of releases) {
-      if (release.fixes.length === 0 && release.merges.length === 0) {
-        expect(release.commits.length).to.equal(1)
-      }
-    }
-  })
-
-  it('parses releases with summary', async () => {
-    const releases = await parseReleases(tags, remotes.bitbucket, null, { ...options, releaseSummary: true })
-    expect(releases[0].summary).to.equal('This is my major release description.\n\n- And a bullet point')
-  })
-
-  it('parses bitbucket releases', async () => {
-    const releases = await parseReleases(tags, remotes.bitbucket, null, options)
-    expect(releases[0].href).to.equal('https://bitbucket.org/user/repo/compare/v1.0.0..v0.1.0')
-  })
-
-  it('parses azure devops releases', async () => {
-    const releases = await parseReleases(tags, remotes.azure, null, options)
-    expect(releases[0].href).to.equal('https://dev.azure.com/user/project/_git/repo/branches?baseVersion=GTv1.0.0&targetVersion=GTv0.1.0&_a=commits')
-  })
-
-  it('parses visual studio releases', async () => {
-    const releases = await parseReleases(tags, remotes.visualstudio, null, options)
-    expect(releases[0].href).to.equal('https://user.visualstudio.com/project/_git/repo/branches?baseVersion=GTv1.0.0&targetVersion=GTv0.1.0&_a=commits')
-  })
-
-  it('sorts releases in the correct order', async () => {
-    const releases = await parseReleases(tags, remotes.bitbucket, null, { ...options, unreleased: true })
-    expect(releases.map(item => item.tag)).to.deep.equal([null, 'v1.0.0', 'v0.1.0', 'v0.0.2', 'v0.0.1'])
-  })
-
-  it('includes tag prefix in compare urls', async () => {
-    const releases = await parseReleases(tags, remotes.bitbucket, null, { ...options, tagPrefix: 'prefix-' })
-    expect(releases[0].href).to.equal('https://bitbucket.org/user/repo/compare/prefix-v1.0.0..prefix-v0.1.0')
-  })
-
-  it('supports a version override', async () => {
-    const releases = await parseReleases(tags, remotes.github, 'v3.0.0', options)
-    expect(releases).to.be.an('array')
-    expect(releases[0]).to.have.property('tag', 'v3.0.0')
-  })
-
-  it.skip('supports sortCommits options', async () => {
-    const releases = await parseReleases(commitsSingleRelease, remotes.github, null, {
-      ...options,
-      sortCommits: 'date',
-      commitLimit: false
-    })
-    expect(releases).to.be.an('array')
-    expect(releases[0].commits.map(c => c.date)).to.deep.equal([
-      '2015-12-14T17:06:12.000Z',
-      '2015-12-29T21:18:19.000Z',
-      '2015-12-29T21:19:19.000Z',
-      '2015-12-29T21:57:19.000Z'
-    ])
-  })
-
-  it('supports ignoreCommitPattern option', async () => {
-    const options = { ignoreCommitPattern: 'Some breaking change' }
-    const releases = await parseReleases(tags, remotes.github, null, options)
-    expect(releases).to.have.length(4)
-    expect(JSON.stringify(releases)).to.not.contain('Some breaking change')
-  })
-})
diff --git a/test/tags.js b/test/tags.js
index 43f62a7b..246653b1 100644
--- a/test/tags.js
+++ b/test/tags.js
@@ -1,21 +1,27 @@
 const { describe, it, beforeEach, afterEach } = require('mocha')
 const { expect } = require('chai')
+const remotes = require('./data/remotes')
 const {
   fetchTags,
-  __get__,
   __Rewire__: mock,
   __ResetDependency__: unmock
 } = require('../src/tags')
 
 const options = {
-  tagPrefix: ''
+  tagPrefix: '',
+  ...remotes.github
 }
 
-const sortTags = __get__('sortTags')(options)
-
 describe('fetchTags', () => {
   beforeEach(() => {
-    mock('cmd', () => Promise.resolve('v0.1.0---2000-02-01\nv0.2.0---2000-03-01\nv0.2.1---2000-03-02\nv0.2.2---2000-03-03\nv0.3.0---2000-04-01\nv1.0.0---2001-01-01'))
+    mock('cmd', () => Promise.resolve([
+      'v0.1.0---2000-02-01',
+      'v0.2.0---2000-03-01',
+      'v0.2.1---2000-03-02',
+      'v0.2.2---2000-03-03',
+      'v0.3.0---2000-04-01',
+      'v1.0.0---2001-01-01'
+    ].join('\n')))
   })
 
   afterEach(() => {
@@ -23,53 +29,108 @@ describe('fetchTags', () => {
   })
 
   it('fetches tags', async () => {
-    expect(await fetchTags(options)).to.deep.equal([
-      { tag: 'v1.0.0', date: '2001-01-01' },
-      { tag: 'v0.3.0', date: '2000-04-01' },
-      { tag: 'v0.2.2', date: '2000-03-03' },
-      { tag: 'v0.2.1', date: '2000-03-02' },
-      { tag: 'v0.2.0', date: '2000-03-01' },
-      { tag: 'v0.1.0', date: '2000-02-01' }
-    ])
+    expect(await fetchTags(options)).to.deep.equal([{
+      tag: 'v1.0.0',
+      version: 'v1.0.0',
+      title: 'v1.0.0',
+      date: '2001-01-01',
+      isoDate: '2001-01-01',
+      niceDate: '1 January 2001',
+      diff: 'v0.3.0..v1.0.0',
+      href: 'https://github.com/user/repo/compare/v0.3.0...v1.0.0',
+      major: true
+    },
+    {
+      tag: 'v0.3.0',
+      version: 'v0.3.0',
+      title: 'v0.3.0',
+      date: '2000-04-01',
+      isoDate: '2000-04-01',
+      niceDate: '1 April 2000',
+      diff: 'v0.2.2..v0.3.0',
+      href: 'https://github.com/user/repo/compare/v0.2.2...v0.3.0',
+      major: false
+    },
+    {
+      tag: 'v0.2.2',
+      version: 'v0.2.2',
+      title: 'v0.2.2',
+      date: '2000-03-03',
+      isoDate: '2000-03-03',
+      niceDate: '3 March 2000',
+      diff: 'v0.2.1..v0.2.2',
+      href: 'https://github.com/user/repo/compare/v0.2.1...v0.2.2',
+      major: false
+    },
+    {
+      tag: 'v0.2.1',
+      version: 'v0.2.1',
+      title: 'v0.2.1',
+      date: '2000-03-02',
+      isoDate: '2000-03-02',
+      niceDate: '2 March 2000',
+      diff: 'v0.2.0..v0.2.1',
+      href: 'https://github.com/user/repo/compare/v0.2.0...v0.2.1',
+      major: false
+    },
+    {
+      tag: 'v0.2.0',
+      version: 'v0.2.0',
+      title: 'v0.2.0',
+      date: '2000-03-01',
+      isoDate: '2000-03-01',
+      niceDate: '1 March 2000',
+      diff: 'v0.1.0..v0.2.0',
+      href: 'https://github.com/user/repo/compare/v0.1.0...v0.2.0',
+      major: false
+    },
+    {
+      tag: 'v0.1.0',
+      version: 'v0.1.0',
+      title: 'v0.1.0',
+      date: '2000-02-01',
+      isoDate: '2000-02-01',
+      niceDate: '1 February 2000',
+      diff: 'v0.1.0',
+      href: null,
+      major: false
+    }])
   })
 
   it('supports --starting-version', async () => {
-    expect(await fetchTags({ ...options, startingVersion: 'v0.3.0' })).to.deep.equal([
-      { tag: 'v1.0.0', date: '2001-01-01' },
-      { tag: 'v0.3.0', date: '2000-04-01' },
-      { tag: 'v0.2.2', date: '2000-03-03' }
-    ])
-  })
-})
-
-describe('sortTags', () => {
-  it('compares semver tags', () => {
-    expect(sortTags({ tag: '1.0.0' }, { tag: '0.1.0' })).to.equal(-1)
-    expect(sortTags({ tag: '0.1.0' }, { tag: '1.0.0' })).to.equal(1)
-    expect(sortTags({ tag: '0.1.0' }, { tag: '0.1.0' })).to.equal(0)
-  })
-
-  it('supports non-semver tags', () => {
-    expect(sortTags({ tag: 'abc' }, { tag: 'def' })).to.equal(1)
-    expect(sortTags({ tag: 'def' }, { tag: 'abc' })).to.equal(-1)
-    expect(sortTags({ tag: 'abc' }, { tag: 'abc' })).to.equal(0)
+    expect(await fetchTags({ ...options, startingVersion: 'v0.2.2' })).to.have.lengthOf(3)
   })
 
-  it('supports non-semver numeric tags', () => {
-    expect(sortTags({ tag: '22.1' }, { tag: '22.0' })).to.equal(-1)
-    expect(sortTags({ tag: '22.0' }, { tag: '22.1' })).to.equal(1)
-    expect(sortTags({ tag: '123.0' }, { tag: '22.1' })).to.equal(-1)
-    expect(sortTags({ tag: '0.1' }, { tag: '0.01' })).to.equal(-1)
-    expect(sortTags({ tag: '0.14' }, { tag: '0.2' })).to.equal(-1)
-    expect(sortTags({ tag: '0.2' }, { tag: '0.14' })).to.equal(1)
+  it('supports partial semver tags', async () => {
+    mock('cmd', () => Promise.resolve([
+      'v0.1---2000-02-01',
+      'v0.2---2000-03-01',
+      'v0.2.1---2000-03-02',
+      'v0.2.2---2000-03-03',
+      'v0.3---2000-04-01',
+      'v1---2001-01-01'
+    ].join('\n')))
+    const tags = await fetchTags(options)
+    expect(tags.map(t => t.version)).to.deep.equal([
+      'v1.0.0',
+      'v0.3.0',
+      'v0.2.2',
+      'v0.2.1',
+      'v0.2.0',
+      'v0.1.0'
+    ])
   })
 
-  it('supports partial semver tags', () => {
-    expect(sortTags({ tag: 'v0.50.7' }, { tag: 'v0.51' })).to.equal(1)
-    expect(sortTags({ tag: 'v0.51' }, { tag: 'v0.50.7' })).to.equal(-1)
-    expect(sortTags({ tag: 'v0.6' }, { tag: 'v0.50.7' })).to.equal(1)
-    expect(sortTags({ tag: 'v0.50.7' }, { tag: 'v0.6' })).to.equal(-1)
-    expect(sortTags({ tag: 'v2' }, { tag: 'v11' })).to.equal(1)
-    expect(sortTags({ tag: 'v11' }, { tag: 'v2' })).to.equal(-1)
+  it('ignores invalid semver tags', async () => {
+    mock('cmd', () => Promise.resolve([
+      'v0.1.0---2000-02-01',
+      'invalid-semver-tag---2000-03-01',
+      'v0.2.0---2000-03-02'
+    ].join('\n')))
+    const tags = await fetchTags(options)
+    expect(tags.map(t => t.version)).to.deep.equal([
+      'v0.2.0',
+      'v0.1.0'
+    ])
   })
 })
diff --git a/test/template.js b/test/template.js
index 864ca099..0109eadc 100644
--- a/test/template.js
+++ b/test/template.js
@@ -8,33 +8,33 @@ const { compileTemplate } = require('../src/template')
 describe('compileTemplate', () => {
   it('compiles using compact template', async () => {
     const expected = await readFile(join(__dirname, 'data', 'template-compact.md'))
-    expect(await compileTemplate({ template: 'compact' }, { releases })).to.equal(expected)
+    expect(await compileTemplate(releases, { template: 'compact' })).to.equal(expected)
   })
 
   it('compiles using keepachangelog template', async () => {
     const expected = await readFile(join(__dirname, 'data', 'template-keepachangelog.md'))
-    expect(await compileTemplate({ template: 'keepachangelog' }, { releases })).to.equal(expected)
+    expect(await compileTemplate(releases, { template: 'keepachangelog' })).to.equal(expected)
   })
 
   it('compiles using json template', async () => {
     const expected = await readFile(join(__dirname, 'data', 'template-json.json'))
-    expect(await compileTemplate({ template: 'json' }, { releases })).to.equal(expected)
+    expect(await compileTemplate(releases, { template: 'json' })).to.equal(expected)
   })
 
   it('compiles using path to template file', async () => {
     const path = join(__dirname, 'data', 'template-compact.md')
     const expected = await readFile(path)
-    expect(await compileTemplate({ template: path }, { releases })).to.equal(expected)
+    expect(await compileTemplate(releases, { template: path })).to.equal(expected)
   })
 
   it('compiles using url path', async () => {
     const path = 'https://raw.githubusercontent.com/CookPete/auto-changelog/master/templates/compact.hbs'
     const expected = await readFile(join(__dirname, 'data', 'template-compact.md'))
-    expect(await compileTemplate({ template: path }, { releases })).to.equal(expected)
+    expect(await compileTemplate(releases, { template: path })).to.equal(expected)
   }).timeout(10000)
 
   it('throws an error when no template found', done => {
-    compileTemplate({ template: 'not-found' }, { releases })
+    compileTemplate(releases, { template: 'not-found' })
       .then(() => done('Should throw an error'))
       .catch(() => done())
   })
@@ -42,9 +42,9 @@ describe('compileTemplate', () => {
   it('supports handlebarsSetup option', async () => {
     const path = join(__dirname, 'data', 'template-custom-helper.md')
     const expected = await readFile(join(__dirname, 'data', 'template-custom-helper-compiled.md'))
-    expect(await compileTemplate({
+    expect(await compileTemplate(releases, {
       template: path,
       handlebarsSetup: './test/data/handlebars-setup.js'
-    }, { releases })).to.equal(expected)
+    })).to.equal(expected)
   })
 })