Refactored to use esbuild

src/lib/docker.js

@@ -0,0 +1,16 @@
+import Regex from './regex.js'
+import path from 'path'
+import fs from 'fs'
+import core from '@actions/core'
+
+export default class Dockerfile extends Regex {
+  constructor (root = null) {
+    root = path.join(process.env.GITHUB_WORKSPACE, root)
+
+    if (fs.statSync(root).isDirectory()) {
+      root = path.join(root, 'Dockerfile')
+    }
+
+    super(root, /LABEL[\s\t]+version=[\t\s+]?[\"\']?([0-9\.]+)[\"\']?/i)
+  }
+}

src/lib/package.js

@@ -0,0 +1,23 @@
+import fs from 'fs'
+import path from 'path'
+
+export default class Package {
+  constructor (root = './') {
+    root = path.join(process.env.GITHUB_WORKSPACE, root)
+
+    if (fs.statSync(root).isDirectory()) {
+      root = path.join(root, 'package.json')
+    }
+
+    if (!fs.existsSync(root)) {
+      throw new Error(`package.json does not exist at ${root}.`)
+    }
+
+    this.root = root
+    this.data = JSON.parse(fs.readFileSync(root))
+  }
+
+  get version () {
+    return this.data.version
+  }
+}

src/lib/regex.js

@@ -0,0 +1,36 @@
+import fs from 'fs'
+import path from 'path'
+
+export default class Regex {
+  constructor (root = './', pattern) {
+    root = path.resolve(root)
+
+    if (fs.statSync(root).isDirectory()) {
+      throw new Error(`${root} is a directory. The Regex tag identification strategy requires a file.`)
+    }
+
+    if (!fs.existsSync(root)) {
+      throw new Error(`"${root}" does not exist.`)
+    }
+
+    this.content = fs.readFileSync(root).toString()
+
+    let content = pattern.exec(this.content)
+    if (!content) {
+      this._version = null
+      // throw new Error(`Could not find pattern matching "${pattern.toString()}" in "${root}".`)
+    } else if (content.groups && content.groups.version) {
+      this._version = content.groups.version
+    } else {
+      this._version = content[1]
+    }
+  }
+
+  get version () {
+    return this._version
+  }
+
+  get versionFound () {
+    return this._version !== null
+  }
+}

src/lib/setup.js

@@ -0,0 +1,33 @@
+import core from '@actions/core'
+import fs from 'fs'
+import path from 'path'
+
+export default class Setup {
+  static debug () {
+    // Metadate for debugging
+    core.debug(
+      ` Available environment variables:\n -> ${Object.keys(process.env)
+        .map(i => i + ' :: ' + process.env[i])
+        .join('\n -> ')}`
+    )
+
+    const dir = fs
+      .readdirSync(path.resolve(process.env.GITHUB_WORKSPACE), { withFileTypes: true })
+      .map(entry => {
+        return `${entry.isDirectory() ? '> ' : '  - '}${entry.name}`
+      })
+      .join('\n')
+
+    core.debug(` Working Directory: ${process.env.GITHUB_WORKSPACE}:\n${dir}`)
+  }
+
+  static requireAnyEnv () {
+    for (const arg of arguments) {
+      if (!process.env.hasOwnProperty(arg)) {
+        return
+      }
+    }
+
+    throw new Error('At least one of the following environment variables is required: ' + Array.slice(arguments).join(', '))
+  }
+}

src/lib/tag.js

@@ -0,0 +1,176 @@
+import core from '@actions/core'
+import os from 'os'
+import gh from '@actions/github'
+
+// Get authenticated GitHub client (Ocktokit): https://github.com/actions/toolkit/tree/master/packages/github#usage
+const github = new gh.GitHub(process.env.GITHUB_TOKEN || process.env.INPUT_GITHUB_TOKEN)
+// Get owner and repo from context of payload that triggered the action
+const { owner, repo } = gh.context.repo
+
+export default class Tag {
+  constructor (prefix, version, postfix) {
+    this.prefix = prefix
+    this.version = version
+    this.postfix = postfix
+    this._tags = null
+    this._message = null
+    this._exists = null
+    this._sha = ''
+    this._uri = ''
+    this._ref = ''
+  }
+
+  get name () {
+    return `${this.prefix.trim()}${this.version.trim()}${this.postfix.trim()}`
+  }
+
+  set message (value) {
+    if (value && value.length > 0) {
+      this._message = value
+    }
+  }
+
+  get message() {
+    return this._message || ''
+  }
+
+  get sha () {
+    return this._sha || ''
+  }
+
+  get uri () {
+    return this._uri || ''
+  }
+
+  get ref () {
+    return this._ref || ''
+  }
+
+  get prerelease () {
+    return /([0-9\.]{5}(-[\w\.0-9]+)?)/i.test(this.version)
+  }
+
+  get build () {
+    return /([0-9\.]{5}(\+[\w\.0-9]+)?)/i.test(this.version)
+  }
+
+  async getMessage () {
+    if (this._message !== null) {
+      return this._message
+    }
+
+    try {
+      let tags = await this.getTags()
+
+      if (tags.length === 0) {
+        return `Version ${this.version}`
+      }
+
+      const changelog = await github.repos.compareCommits({ owner, repo, base: tags.shift().name, head: 'master' })
+
+      const tpl = (core.getInput('commit_message_template', { required: false }) || '').trim()
+
+      return changelog.data.commits
+        .map(
+          (commit, i) => {
+            if (tpl.length > 0) {
+              return tpl
+                .replace(/\{\{\s?(number)\s?\}\}/gi, i + 1)
+                .replace(/\{\{\s?(message)\s?\}\}/gi, commit.commit.message)
+                .replace(/\{\{\s?(author)\s?\}\}/gi, commit.hasOwnProperty('author') ? (commit.author.hasOwnProperty('login') ? commit.author.login : '') : '')
+                .replace(/\{\{\s?(sha)\s?\}\}/gi, commit.sha)
+                .trim() + '\n'
+            } else {
+              return `${i === 0 ? '\n' : ''}${i + 1}) ${commit.commit.message}${
+                commit.hasOwnProperty('author')
+                  ? commit.author.hasOwnProperty('login')
+                    ? ' (' + commit.author.login + ')'
+                    : ''
+                  : ''
+              }\n(SHA: ${commit.sha})\n`
+            }
+          })
+        .join('\n')
+    } catch (e) {
+      core.warning('Failed to generate changelog from commits: ' + e.message + os.EOL)
+      return `Version ${this.version}`
+    }
+  }
+
+  async getTags () {
+    if (this._tags !== null) {
+      return this._tags.data
+    }
+
+    this._tags = await github.repos.listTags({ owner, repo, per_page: 100 })
+
+    return this._tags.data
+  }
+
+  async exists () {
+    if (this._exists !== null) {
+      return this._exists
+    }
+    const currentTag = this.name
+    const tags = await this.getTags()
+
+    for (const tag of tags) {
+      if (tag.name === currentTag) {
+        this._exists = true
+        return true
+      }
+    }
+
+    this._exists = false
+    return false
+  }
+
+  async push () {
+    let tagexists = await this.exists()
+
+    if (!tagexists) {
+      // Create tag
+      const message = await this.getMessage()
+      const newTag = await github.git.createTag({
+        owner,
+        repo,
+        tag: this.name,
+        message,
+        object: process.env.GITHUB_SHA,
+        type: 'commit'
+      })
+
+      this._sha = newTag.data.sha
+      core.warning(`Created new tag: ${newTag.data.tag}`)
+
+      // Create reference
+      let newReference
+
+      try {
+        newReference = await github.git.createRef({
+          owner,
+          repo,
+          ref: `refs/tags/${newTag.data.tag}`,
+          sha: newTag.data.sha
+        })
+      } catch (e) {
+        core.warning({
+          owner,
+          repo,
+          ref: `refs/tags/${newTag.data.tag}`,
+          sha: newTag.data.sha
+        })
+
+        throw e
+      }
+
+      this._uri = newReference.data.url
+      this._ref = newReference.data.ref
+      this._message = message;
+
+      core.warning(`Reference ${newReference.data.ref} available at ${newReference.data.url}` + os.EOL)
+    } else {
+      core.warning('Cannot push tag (it already exists).')
+    }
+  }
+}