add better support & control for versions & tags

Fixes #8 & #9

Author: Rohith Reddy

README.md

@@ -2,52 +2,57 @@
 GitHub action to build, pack & publish nuget packages automatically when a project version is updated
 
 ## Usage
-Create a new `.github/workflows/publish-nuget.yml` file:
+Create new `.github/workflows/publish.yml` file:
 
-```yaml
+```yml
 name: publish to nuget
 on:
   push:
     branches:
       - master # Your default release branch
 jobs:
   publish:
-    name: publish to nuget
+    name: list on nuget
     runs-on: ubuntu-latest
     steps:
-      # Checkout
       - uses: actions/checkout@v2
 
-      # Optional step, add only for a specific dotnet version that doesn't come with ubuntu-latest / windows-latest
-      # Visit bit.ly/2synnZl for a list of software that comes pre-installed with ubuntu-latest / windows-latest
+      # Required for a specific dotnet version that doesn't come with ubuntu-latest / windows-latest
+      # Visit bit.ly/2synnZl to see the list of SDKs that are pre-installed with ubuntu-latest / windows-latest
       # - name: Setup dotnet
       #   uses: actions/setup-dotnet@v1
       #   with:
       #     dotnet-version: 3.1.100
 
       # Publish
-      - name: Publish if version is updated
-        uses: rohith/publish-nuget@v1
-        # with: # All inputs are optional (details given below)
-        #   project_dir: src # Defaults to repository root
-        #   tag_format: v* # [*] gets replaced with version
-        #   nuget_key: ${{secrets.NUGET_API_KEY}} # nuget.org API key
+      - name: publish on version change
+        uses: rohith/publish-nuget@v2
+        with:
+          PROJECT_FILE_PATH: Core/Core.csproj # Relative to repository root
+          # VERSION_FILE_PATH: Directory.Build.props # Filepath with version info, relative to repository root. Defaults to project file
+          # VERSION_REGEX: <Version>(.*)<\/Version> # Regex pattern to extract version info in a capturing group
+          # TAG_COMMIT: true # Flag to enable / disalge git tagging
+          # TAG_FORMAT: v* # Format of the git tag, [*] gets replaced with version
+          # NUGET_KEY: ${{secrets.NUGET_API_KEY}} # nuget.org API key
 ```
 
-- Project version updates are monitored on every push / PR merge to master & a new tag is created to denote the updated version
-- If a `nuget_key` is present then the project gets built, packed & published to nuget.org
+- With all settings on default, updates to project version are monitored on every push / PR merge to master & a new tag is created
+- If a `NUGET_KEY` is present then the project gets built, packed & published to nuget.org
 
 ## Inputs
-All these inputs are optional
+Most of the inputs are optional
 
-Input | Description
---- | ---
-project_dir | Directory path containing the project file, defaults to repository root
-tag_format | Defaults to `v*` - `[*]` is a placeholder for the actual project version
-nuget_key | API key to authorize the package upload to nuget.org
+Input | Default Value | Description
+--- | --- | ---
+PROJECT_FILE_PATH | | File path of the project to be packaged, relative to repository root
+VERSION_FILE_PATH | `[PROJECT_FILE_PATH]` | File path containing version info, relative to repository root
+VERSION_REGEX | `<Version>(.*)<\/Version>` | Regex pattern to extract version info in a capturing group
+TAG_COMMIT | `true` | Flag to enable / disable git tagging
+TAG_FORMAT | `v*` | `[*]` is a placeholder for the actual project version
+NUGET_KEY | | API key to authorize the package upload to nuget.org
 
 **Note:**  
-`project_dir` & `tag_format` have default values but a package cannot be published without the `nuget_key`
+For multiple projects, every input except `PROJECT_FILE_PATH` can be given as `env` variable at [job / workflow level](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#env)
 
 ## License
 [MIT](LICENSE)

action.yml

@@ -1,17 +1,27 @@
 name: Publish NuGet
 author: Rohith Reddy (@rohith)
-description: Build, Pack & Publish NuGet packages with dotnet (.net core) on project version change
+description: Build, Pack & Publish NuGet packages with dotnet (.net) core on project version change
 
 inputs:
-    project_dir:
-        description: Project (csproj) directory path relative from the root of repository
+    PROJECT_FILE_PATH:
+        description: Filepath of the project to be packaged, relative to root of repository
+        required: true
+    VERSION_FILE_PATH:
+        description: Filepath containing version info, relative to root of repository. Defaults to `PROJECT_FILE_PATH` if not specified
         required: false
-        default: .
-    tag_format:
-        description: Format of the tag to be created, `*` is placeholder for actual version
+    VERSION_REGEX:
+        description: Regex (with version in a capturing group) to extract the version from `VERSION_FILE_PATH`
+        required: false
+        default: <Version>(.*)<\/Version>
+    TAG_COMMIT:
+        description: Whether to create a tag when there's a version change or not
+        required: false
+        default: true
+    TAG_FORMAT:
+        description: Format of the tag, `*` is the placeholder for actual version
         required: false
         default: v*
-    nuget_key:
+    NUGET_KEY:
         description: API key for the NuGet feed
         required: false
 

index.js

@@ -1,78 +1,120 @@
-const resolve = require("path").resolve,
+const path = require("path"),
     spawnSync = require("child_process").spawnSync,
-    { readdirSync, readFileSync } = require("fs")
+    fs = require("fs"),
+    https = require("https")
+
+class Action {
+    constructor() {
+        this.PROJECT_FILE_PATH = process.env.INPUT_PROJECT_FILE_PATH
+        this.VERSION_FILE_PATH = process.env.INPUT_VERSION_FILE_PATH || process.env.VERSION_FILE_PATH
+        this.VERSION_REGEX = new RegExp(process.env.INPUT_VERSION_REGEX || process.env.VERSION_REGEX)
+        this.TAG_COMMIT = JSON.parse(process.env.INPUT_TAG_COMMIT || process.env.TAG_COMMIT)
+        this.TAG_FORMAT = process.env.INPUT_TAG_FORMAT || process.env.TAG_FORMAT
+        this.NUGET_KEY = process.env.INPUT_NUGET_KEY || process.env.NUGET_KEY
+    }
 
-function run() {
-    // find project
-    const repoDir = process.env.GITHUB_WORKSPACE,
-        projDir = resolve(repoDir, process.env.INPUT_PROJECT_DIR),
-        projFiles = readdirSync(projDir).filter(f => f.endsWith(".csproj") || f.endsWith(".fsproj"))
+    _warn(msg) {
+        console.log(`##[warning]${msg}`)
+    }
 
-    if (projFiles.length === 0) {
-        failed("😭 project not found")
-        return
+    _fail(msg) {
+        console.log(`##[error]${msg}`)
+        throw new Error(msg)
     }
 
-    // check for new version
-    const projName = projFiles[0],
-        projPath = resolve(projDir, projName),
-        versionRegex = /<Version>(.*)<\/Version>/,
-        projDetails = readFileSync(projPath, { encoding: "utf-8" }),
-        isVersionPresent = versionRegex.test(projDetails)
+    _execCmd(cmd, options) {
+        const INPUT = cmd.split(" "), TOOL = INPUT[0], ARGS = INPUT.slice(1)
+        return spawnSync(TOOL, ARGS, options)
+    }
 
-    if (!isVersionPresent) {
-        console.log(`##[warning]😢 skipping due to no version`)
-        return
+    _execAndCapture(cmd) {
+        return this._execCmd(cmd, { encoding: "utf-8" }).stdout
     }
 
-    const currentVersion = versionRegex.exec(projDetails)[1],
-        tagFormat = process.env.INPUT_TAG_FORMAT,
-        tag = tagFormat.replace("*", currentVersion),
-        istagPresent = runCap(`git ls-remote --tags origin ${tag}`).indexOf(tag) >= 0
+    _execInProc(cmd) {
+        this._execCmd(cmd, { encoding: "utf-8", stdio: [process.stdin, process.stdout, process.stderr] })
+    }
 
-    if (istagPresent) {
-        console.log(`##[warning]😢 tag ${currentVersion} already exists`)
-        return
+    _resolveIfExists(filePath, msg) {
+        const FULLPATH = path.resolve(process.env.GITHUB_WORKSPACE, filePath)
+        if (!fs.existsSync(FULLPATH)) this._fail(msg)
+        return FULLPATH
     }
 
-    console.log(`👍 found a new version (${currentVersion}) of ${projName}`)
+    _pushPackage() {
+        if (!this.NUGET_KEY) {
+            this._warn("😢 nuget_key not given")
+            return
+        }
 
-    runProc(`git tag ${tag}`)
-    runProc(`git push origin ${tag}`)
+        if (!this._execAndCapture("dotnet --version")) {
+            this._warn("😭 dotnet not found")
+            return
+        }
 
-    // pack & push
-    const nugetKey = process.env.INPUT_NUGET_KEY
+        this._execInProc(`dotnet pack -c Release ${this.PROJECT_FILE_PATH} -o .`)
+        const NUGET_PUSH_RESPONSE = this._execAndCapture(`dotnet nuget push *.nupkg -s https://api.nuget.org/v3/index.json -k ${this.NUGET_KEY}`)
+        const NUGET_ERROR_REGEX = /(error: Response status code does not indicate success.*)/
 
-    if (!nugetKey) {
-        console.log(`##[warning]😢 nuget_key not found`)
-        return
+        if (NUGET_ERROR_REGEX.test(NUGET_PUSH_RESPONSE))
+            this._fail(`😭 ${NUGET_ERROR_REGEX.exec(NUGET_PUSH_RESPONSE)[1]}`)
     }
 
-    if (!runCap("dotnet --version")) {
-        failed("😭 dotnet not found")
-        return
+    _tagCommit(version) {
+        if (this.TAG_COMMIT) {
+            const TAG = this.TAG_FORMAT.replace("*", version)
+
+            if (this._execAndCapture(`git ls-remote --tags origin ${TAG}`).indexOf(TAG) >= 0) {
+                this._warn(`😢 tag ${TAG} already exists`)
+                return
+            }
+
+            this._execInProc(`git tag ${TAG}`)
+            this._execInProc(`git push origin ${TAG}`)
+        }
     }
 
-    runProc(`dotnet pack -c Release ${projPath} -o .`)
-    const out = runCap(`dotnet nuget push *.nupkg -s https://api.nuget.org/v3/index.json -k ${nugetKey}`)
-    const errorRegex = /(error: Response status code does not indicate success.*)/
+    _pushAndTag(CURRENT_VERSION, PACKAGE_NAME) {
+        console.log(`👍 found a new version (${CURRENT_VERSION}) of ${PACKAGE_NAME}`)
+        this._tagCommit(CURRENT_VERSION)
+        this._pushPackage()
+    }
 
-    if (errorRegex.test(out))
-        failed(`😭 ${errorRegex.exec(out)[1]}`)
-}
+    run() {
+        if (!this.PROJECT_FILE_PATH)
+            this._fail("😭 project file not given")
 
-function runCap(cmd) { return runCmd(cmd, { encoding: "utf-8" }).stdout }
+        this.PROJECT_FILE_PATH = this._resolveIfExists(this.PROJECT_FILE_PATH, "😭 project file not found")
+        this.VERSION_FILE_PATH = !this.VERSION_FILE_PATH ? this.PROJECT_FILE_PATH : this._resolveIfExists(this.VERSION_FILE_PATH, "😭 version file not found")
 
-function runProc(cmd) { runCmd(cmd, { encoding: "utf-8", stdio: [process.stdin, process.stdout, process.stderr] }) }
+        const FILE_CONTENT = fs.readFileSync(this.VERSION_FILE_PATH, { encoding: "utf-8" }),
+            VERSION_INFO = this.VERSION_REGEX.exec(FILE_CONTENT)
 
-function runCmd(cmd, options) {
-    const input = cmd.split(" "), tool = input[0], args = input.slice(1)
-    return spawnSync(tool, args, options)
-}
+        if (!VERSION_INFO)
+            this._fail("😢 unable to extract version info")
+
+        const CURRENT_VERSION = VERSION_INFO[1],
+            PACKAGE_NAME = path.basename(this.PROJECT_FILE_PATH).split(".").slice(0, -1).join(".")
 
-function failed(msg) {
-    process.exitCode = 1
-    console.log(`##[error]${msg}`)
+        https.get(`https://api.nuget.org/v3-flatcontainer/${PACKAGE_NAME}/index.json`, res => {
+            let body = ""
+
+            if (res.statusCode == 404)
+                this._pushAndTag(CURRENT_VERSION, PACKAGE_NAME)
+
+            if (res.statusCode == 200) {
+                res.setEncoding("utf8")
+                res.on("data", chunk => body += chunk)
+                res.on("end", () => {
+                    const existingVersions = JSON.parse(body)
+                    if (existingVersions.versions.indexOf(CURRENT_VERSION) < 0)
+                        this._pushAndTag(CURRENT_VERSION, PACKAGE_NAME)
+                })
+            }
+        }).on("error", e => {
+            this._warn(`😢 error reaching nuget.org ${e.message}`)
+        })
+    }
 }
 
-run()
+new Action().run()