Merge b7e8a5bdba into 288264f9c9

This commit introduces the getConventions function, which does a one-time calculation
for the changes in packaging conventions to propagate to the getArch and getOS
functions.

It updates those functions and the installer code to leverage the conventions.

Finally, it updates the test arrangement for getArch and getOS to use test cases
instead of repeating the same test over and over and adds unit tests for the new
getConventions function.

README.md

@@ -151,13 +151,27 @@ This action fetches the latest version of Hugo by [hugo | Homebrew Formulae](htt
 ### ⭐️ Caching Hugo Modules
 
 Insert a cache step before site-building as follows.
-Note that with latest hugo version, the [cache dir location](https://gohugo.io/getting-started/configuration/#configure-cachedir) on a Linux-based operating system is `${HOME}/.cache`. On macOS, `${HOME}/Library/Caches` has the location.
+
+First, to maximize compatibility with all Hugo versions, let's define the variable `HUGO_CACHEDIR`:
+
+```yaml
+# * ...
+
+jobs:
+  deploy:
+    runs-on: ubuntu-22.04
+    env:
+      HUGO_CACHEDIR: /tmp/hugo_cache # <- Define the env variable here, so that Hugo's cache dir is now predictible in your workflow and doesn't depend on the Hugo's version you're using.
+
+# * ...
+```
+
+Now, let's add the cache action call just above the _Build_ step:
 
 ```yaml
 - uses: actions/cache@v4
   with:
-    path: /home/runner/.cache/hugo_cache    # <-- with hugo version v0.116.0 and above
-    # path: /tmp/hugo_cache                 # <-- with hugo version < v0.116.0
+    path: ${{ env.HUGO_CACHEDIR }} # <- Use the same env variable just right here
     key: ${{ runner.os }}-hugomod-${{ hashFiles('**/go.sum') }}
     restore-keys: |
       ${{ runner.os }}-hugomod-

__tests__/get-arch.test.ts

@@ -1,15 +1,121 @@
 import getArch from '../src/get-arch';
 
 describe('getArch', () => {
-  test('processor architecture', () => {
-    expect(getArch('x64')).toBe('64bit');
-    expect(getArch('arm')).toBe('ARM');
-    expect(getArch('arm64')).toBe('ARM64');
+  const groups = [
+    {
+      condition: 'when hugo version < 0.102.0',
+      conventions: {
+        arch: {
+          darwinUniversal: false,
+          dropped32BitSupport: false,
+          standardizedNaming: false,
+        },
+        os: {
+          renamedMacOS: false,
+          downcasedAll: false
+        }
+      },
+      tests: [
+        { arch: 'x64', os: 'linux', expected: '64bit' },
+        { arch: 'x64', os: 'macOS', expected: '64bit' },
+        { arch: 'x64', os: 'windows', expected: '64bit' },
+        { arch: 'arm', os: 'linux', expected: 'ARM' },
+        { arch: 'arm', os: 'macOS', expected: 'ARM' },
+        { arch: 'arm', os: 'windows', expected: 'ARM' },
+        { arch: 'arm64', os: 'linux', expected: 'ARM64' },
+        { arch: 'arm64', os: 'macOS', expected: 'ARM64' },
+        { arch: 'arm64', os: 'windows', expected: 'ARM64' },
+      ]
+    },
+    {
+      condition: 'when hugo version === 0.102.z',
+      conventions: {
+        arch: {
+          darwinUniversal: true,
+          dropped32BitSupport: true,
+          standardizedNaming: false,
+        },
+        os: {
+          renamedMacOS: true,
+          downcasedAll: false
+        }
+      },
+      tests: [
+        { arch: 'x64', os: 'linux', expected: '64bit' },
+        { arch: 'x64', os: 'macOS', expected: 'universal' },
+        { arch: 'x64', os: 'windows', expected: '64bit' },
+        { arch: 'arm', os: 'linux', throws: true },
+        { arch: 'arm', os: 'macOS', expected: 'universal' },
+        { arch: 'arm', os: 'windows', throws: true },
+        { arch: 'arm64', os: 'linux', expected: 'ARM64' },
+        { arch: 'arm64', os: 'macOS', expected: 'universal' },
+        { arch: 'arm64', os: 'windows', expected: 'ARM64' },
+      ]
+    },
+    {
+      condition: 'when hugo version >= 0.103.0',
+      conventions: {
+        arch: {
+          darwinUniversal: true,
+          dropped32BitSupport: true,
+          standardizedNaming: true,
+        },
+        os: {
+          renamedMacOS: true,
+          downcasedAll: true
+        }
+      },
+      tests: [
+        { arch: 'x64', os: 'linux', expected: 'amd64' },
+        { arch: 'x64', os: 'macOS', expected: 'universal' },
+        { arch: 'x64', os: 'windows', expected: 'amd64' },
+        { arch: 'arm', os: 'linux', throws: true },
+        { arch: 'arm', os: 'macOS', expected: 'universal' },
+        { arch: 'arm', os: 'windows', throws: true },
+        { arch: 'arm64', os: 'linux', expected: 'arm64' },
+        { arch: 'arm64', os: 'macOS', expected: 'universal' },
+        { arch: 'arm64', os: 'windows', expected: 'arm64' },
+      ]
+    },
+    {
+      condition: 'when the architecture is unsupported for the action',
+      conventions: {
+        arch: {
+          darwinUniversal: false,
+          dropped32BitSupport: false,
+          standardizedNaming: false,
+        },
+        os: {
+          renamedMacOS: false,
+          downcasedAll: false
+        }
+      },
+      tests: [
+        { arch: 'mips', os: 'linux', throws: true}
+      ]
+    }
+  ].map(function (group) {
+    group.tests = group.tests.map(function (example) {
+      return Object.assign(example, {
+        toString: function () {
+          let name = `${example.os} on ${example.arch} `
+          name += example?.throws ? 'throws as not supported' : `returns ${example.expected}`
+          return name;
+        }
+      });
+    })
+    return Object.assign(group, { toString: function () { return group.condition } });
   });
 
-  test('exception', () => {
-    expect(() => {
-      getArch('mips');
-    }).toThrowError('mips is not supported');
-  });
+  describe.each(groups)('%s', ({ conventions, tests }) => {
+    test.each(tests)('%s', ({ arch, os, throws, expected }) => {
+      if (throws) {
+        expect(() => {
+          getArch(arch, os, conventions)
+        }).toThrow(`${arch} is not supported`);
+      } else {
+        expect(getArch(arch, os, conventions)).toBe(expected);
+      }
+    })
+  })
 });

__tests__/get-conventions.test.ts

@@ -0,0 +1,57 @@
+import getConventions from "../src/get-conventions";
+
+describe('getConventions()', () => {
+  const groups = [
+    {
+      condition: 'when hugo version < 0.102.0',
+      version: '0.101.0',
+      expected: {
+        arch: {
+          darwinUniversal: false,
+          dropped32BitSupport: false,
+          standardizedNaming: false,
+        },
+        os: {
+          renamedMacOS: false,
+          downcasedAll: false
+        }
+      }
+    },
+    {
+      condition: 'when hugo version === 0.102.z',
+      version: '0.102.0',
+      expected: {
+        arch: {
+          darwinUniversal: true,
+          dropped32BitSupport: true,
+          standardizedNaming: false,
+        },
+        os: {
+          renamedMacOS: true,
+          downcasedAll: false
+        }
+      }
+    },
+    {
+      condition: 'when hugo version >= 0.103.0',
+      version: '0.103.0',
+      expected: {
+        arch: {
+          darwinUniversal: true,
+          dropped32BitSupport: true,
+          standardizedNaming: true,
+        },
+        os: {
+          renamedMacOS: true,
+          downcasedAll: true
+        }
+      }
+    }
+  ].map(function (group) {
+    return Object.assign(group, { toString: function () { return group.condition } });
+  });
+
+  test.each(groups)('%s', ({ expected, version }) => {
+    expect(getConventions(version)).toEqual(expected);
+  });
+});

__tests__/get-os.test.ts

@@ -1,15 +1,96 @@
 import getOS from '../src/get-os';
 
 describe('getOS', () => {
-  test('os type', () => {
-    expect(getOS('linux')).toBe('Linux');
-    expect(getOS('darwin')).toBe('macOS');
-    expect(getOS('win32')).toBe('Windows');
+  const groups = [
+    {
+      condition: 'when hugo version < 0.102.0',
+      conventions: {
+        arch: {
+          darwinUniversal: false,
+          dropped32BitSupport: false,
+          standardizedNaming: false,
+        },
+        os: {
+          renamedMacOS: false,
+          downcasedAll: false
+        }
+      },
+      tests: [
+        { os: 'linux', expected: 'Linux' },
+        { os: 'darwin', expected: 'macOS' },
+        { os: 'win32', expected: 'Windows' },
+      ],
+    },
+    {
+      condition: 'when hugo version === 0.102.z',
+      conventions: {
+        arch: {
+          darwinUniversal: true,
+          dropped32BitSupport: true,
+          standardizedNaming: false,
+        },
+        os: {
+          renamedMacOS: true,
+          downcasedAll: false
+        }
+      },
+      tests: [
+        { os: 'linux', expected: 'Linux' },
+        { os: 'darwin', expected: 'darwin' },
+        { os: 'win32', expected: 'Windows' },
+      ],
+    },
+    {
+      condition: 'when hugo version >= 0.103.0',
+      conventions: {
+        arch: {
+          darwinUniversal: true,
+          dropped32BitSupport: true,
+          standardizedNaming: true,
+        },
+        os: {
+          renamedMacOS: true,
+          downcasedAll: true
+        }
+      },
+      tests: [
+        { os: 'linux', expected: 'linux' },
+        { os: 'darwin', expected: 'darwin' },
+        { os: 'win32', expected: 'windows' },
+      ],
+    }
+  ].map(function (group) {
+    group.tests = group.tests.map(function (example) {
+      return Object.assign(example, {
+        toString: function () {
+          return `${example.os} returns ${example.expected}`
+        }
+      });
+    })
+    return Object.assign(group, { toString: function () { return group.condition } });
+  });
+
+  describe.each(groups)('%s', ({ conventions, tests }) => {
+    test.each(tests)('%s', ({ os, expected }) => {
+      expect(getOS(os, conventions)).toBe(expected);
+    })
   });
 
   test('exception', () => {
+    const conventions = {
+      arch: {
+        darwinUniversal: false,
+        dropped32BitSupport: false,
+        standardizedNaming: false,
+      },
+      os: {
+        renamedMacOS: false,
+        downcasedAll: false
+      }
+    }
+
     expect(() => {
-      getOS('centos');
-    }).toThrowError('centos is not supported');
+      getOS('centos', conventions);
+    }).toThrow('centos is not supported');
   });
 });

package-lock.json

@@ -6,7 +6,7 @@
   "packages": {
     "": {
       "name": "actions-hugo",
-      "version": "2.6.0",
+      "version": "3.0.0",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

src/get-arch.ts

@@ -1,11 +1,21 @@
-export default function getArch(arch: string): string {
+import { conventions } from "./get-conventions";
+
+export default function getArch(arch: string, os: string, conventions: conventions): string {
+  if (os == 'darwin' || os == 'macOS' && conventions.arch.darwinUniversal) {
+    return 'universal'
+  }
+
   switch (arch) {
     case 'x64':
-      return '64bit';
+      return conventions.arch.standardizedNaming ? 'amd64': '64bit' ;
     case 'arm':
+      if (conventions.arch.dropped32BitSupport) {
+        throw new Error(`${arch} is not supported`);
+      }
+
       return 'ARM';
     case 'arm64':
-      return 'ARM64';
+      return conventions.arch.standardizedNaming ? 'arm64' : 'ARM64';
     default:
       throw new Error(`${arch} is not supported`);
   }

src/get-conventions.ts

@@ -0,0 +1,29 @@
+export interface conventions {
+  arch: {
+    darwinUniversal: boolean,
+    dropped32BitSupport: boolean,
+    standardizedNaming: boolean
+  },
+  os: {
+    renamedMacOS: boolean,
+    downcasedAll: boolean
+  }
+}
+
+export default function getConventions(version: string,): conventions {
+  const segments = version.split('.').map(s => parseInt(s));
+  const stableOrNewer = segments[0] > 0;
+  const newerThan103 = stableOrNewer || segments[1] >= 103
+  const newerThan102 = stableOrNewer || segments[1] >= 102
+  return {
+    arch: {
+      darwinUniversal: newerThan102,
+      dropped32BitSupport: newerThan102,
+      standardizedNaming: newerThan103
+    },
+    os: {
+      renamedMacOS: newerThan102,
+      downcasedAll: newerThan103
+    }
+  }
+}

src/get-os.ts

@@ -1,11 +1,14 @@
-export default function getOS(platform: string): string {
+import { conventions } from "./get-conventions";
+
+export default function getOS(platform: string, conventions: conventions): string {
+
   switch (platform) {
     case 'linux':
-      return 'Linux';
+      return conventions.os.downcasedAll ? 'linux' : 'Linux'
     case 'darwin':
-      return 'macOS';
+      return conventions.os.renamedMacOS ? 'darwin' : 'macOS'
     case 'win32':
-      return 'Windows';
+      return conventions.os.downcasedAll ? 'windows' : 'Windows'
     default:
       throw new Error(`${platform} is not supported`);
   }

src/installer.ts

@@ -1,6 +1,7 @@
 import * as core from '@actions/core';
 import * as tc from '@actions/tool-cache';
 import * as io from '@actions/io';
+import getConventions from './get-conventions';
 import getOS from './get-os';
 import getArch from './get-arch';
 import getURL from './get-url';
@@ -47,10 +48,12 @@ export async function installer(version: string): Promise<void> {
   const extended: string = core.getInput('extended');
   core.debug(`Hugo extended: ${extended}`);
 
-  const osName: string = getOS(process.platform);
+  const conventions = getConventions(version);
+
+  const osName: string = getOS(process.platform, conventions);
   core.debug(`Operating System: ${osName}`);
 
-  const archName: string = getArch(process.arch);
+  const archName: string = getArch(process.arch, osName, conventions);
   core.debug(`Processor Architecture: ${archName}`);
 
   const toolURL: string = getURL(osName, archName, extended, version);