changelog-tool 0.2.0

package/.github/workflows/node.yml

@@ -0,0 +1,45 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  node-test:
+    name: Node.js tests
+
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+
+    strategy:
+      matrix:
+        node-version: [16.x, 18.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm ci
+    - run: npm test
+
+  types:
+    name: Typescript check 
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js
+      uses: actions/setup-node@v1
+      with:
+        node-version: 18.x
+    - run: npm ci
+    - run: npx tsc

package/changelog.md

@@ -0,0 +1,14 @@
+Changelog
+=========
+
+0.2.0 (2023-02-12)
+------------------
+
+* Implemented the 'list' command.
+* Added testing framework based on node:test.
+
+
+0.1.0 (2023-02-08)
+------------------
+
+* Implemented the 'help' and 'init' commands.

package/changelog.mjs

@@ -0,0 +1,119 @@
+import { wrap } from './util.mjs';
+
+// @ts-check
+export class Changelog {
+
+  title = 'Changelog';
+
+  /**
+   * @type {VersionLog[]}
+   */
+  versions = [];
+
+  toString() {
+
+    return (
+      this.title + '\n' +
+      ('='.repeat(this.title.length)) + '\n' +
+      '\n' +
+      this.versions.map(version => version.toString()).join('\n\n') +
+      '\n'
+    );
+
+  }
+
+  /**
+   * Adds a new Version log
+   *
+   * @param version {VersionLog}
+   */
+  add(version) {
+
+    this.versions.push(version);
+
+  }
+
+}
+
+export class VersionLog {
+  
+  /**
+   * @type {string}
+   */
+  version;
+
+  /**
+   * @type {string|null}
+   */
+  date = null;
+
+  /**
+   * @type {string|null}
+   */
+  preface = null;
+
+  /**
+   * @type {string|null}
+   */
+  postface = null;
+
+  /**
+   * @type {LogItem[]}
+   */
+  items = [];
+
+  /**
+   * @param {string} version
+   */
+  constructor(version) {
+    this.version = version;
+
+  }
+
+  /**
+   * @param {string} message
+   */
+  add(message) {
+    this.items.push(new LogItem(message));
+  }
+
+  toString() {
+
+    const title = this.version + ' (' + (this.date ?? '????-??-??') + ')';
+    return (
+      title + '\n' +
+      ('-'.repeat(title.length)) + '\n' +
+      (this.preface ? wrap(this.preface) + '\n' : '') +
+      '\n' +
+      this.items.map(version => version.toString()).join('\n') +
+      '\n' +
+      (this.postface ? wrap(this.postface) + '\n' : '')
+    );
+
+  }
+
+}
+
+export class LogItem {
+
+  /**
+   * @type string
+   */
+  message;
+
+  /**
+   * @param {string} message
+   */
+  constructor(message) {
+    this.message = message;
+  }
+
+  toString() {
+
+    return wrap('* ' + this.message, 2);
+
+  }
+
+}
+
+

package/index.mjs

@@ -0,0 +1,131 @@
+// @ts-check
+import { parseArgs } from 'node:util';
+import * as fs from 'node:fs/promises';
+import * as url from 'node:url';
+import { readPackageVersion, exists } from './util.mjs';
+import { Changelog, VersionLog, LogItem } from './changelog.mjs';
+import { parseFile } from './parse.mjs';
+
+const filename = 'changelog.md';
+
+const pkg = JSON.parse(
+  await fs.readFile(
+    url.fileURLToPath(url.resolve(import.meta.url, './package.json')),
+    'utf-8',
+  )
+);
+
+async function main() {
+
+  const { positionals, values } = parseArgs({
+    options: {
+      help: {
+        type: 'boolean',
+        short: 'h',
+        default: false,
+        description: 'This help screen',
+      },
+    },
+    allowPositionals: true,
+  });
+
+
+
+  if (positionals.length < 1 || values.help) {
+    help();
+    process.exit(1);
+  }
+
+  const command = positionals[0];
+
+  switch(command) {
+    case 'help' :
+      await help();
+      break;
+    case 'init' :
+      await init();
+      break;
+      /*
+    case 'add' :
+      await add();
+      break;
+    case 'release' :
+      await release();
+      break;
+    case 'show' :
+      await show();
+      break;
+      */
+    case 'list' :
+      await list();
+      break;
+    default:
+      process.stderr.write(`Unknown command ${command}\n`);
+      process.exit(1);
+      break;
+  }
+
+}
+
+try {
+  await main();
+} catch (err) {
+  process.stderr.write('Error: ' + err.message + '\n');
+  process.exit(1);
+}
+
+function help() {
+  console.log(
+`Changelog Tool v${pkg.version}
+
+Manipulate your changelog file
+
+Usage:
+
+  changelog init           - Create a new, empty changelog.
+  changelog add [message]  - Adds a new line to the changelog.
+  changelog release        - Marks the current changelog as released.
+  changelog show           - Show the last changelog.
+  changelog show [version] - Show the changelog of a specific version.
+  changelog list           - List all versions in the changelog.
+
+The logs this tool uses follows a specific markdown format. Currently it will
+only look for a file named 'changelog.md' in the current directory.
+
+To see an example of this format, you can either run 'changelog init' or
+check out the changelog shipped with this project:
+
+https://github.com/evert/changelog-tool
+`);
+
+}
+
+async function init() {
+
+  if (await exists(filename)) {
+    throw new Error(`A file named ${filename} already exists`); 
+  }
+
+  const changelog = new Changelog();
+  const version = new VersionLog(await readPackageVersion());
+  version.add('New project!');
+  changelog.versions.push(version); 
+
+  await fs.writeFile(filename, changelog.toString());
+  console.log(`${filename} created`);
+
+}
+
+async function list() {
+
+  if (!await exists(filename)) {
+    throw new Error(`${filename} not found in current directory`);
+  }
+
+  const changelog = await parseFile(filename);
+
+  for(const version of changelog.versions) {
+    console.log(version.version);
+  }
+
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "changelog-tool",
+  "version": "0.2.0",
+  "description": "A CLI tool for manipulating changelogs",
+  "main": "index.mjs",
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "changelog",
+    "markdown"
+  ],
+  "author": "Evert Pot (https://evertpot.com/)",
+  "license": "MIT",
+  "engine": {
+    "node": ">16"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.19",
+    "typescript": "^4.9.5"
+  }
+}

package/parse.mjs

@@ -0,0 +1,56 @@
+// @ts-check
+import { Changelog, VersionLog } from "./changelog.mjs";
+import { readFile } from 'node:fs/promises';
+
+/**
+ * @param {string} filename
+ * @returns {Promise<Changelog>}
+ */
+export async function parseFile(filename) {
+
+  return parse(
+    await readFile(filename, 'utf-8')
+  );
+
+}
+
+/**
+ * @param {string} changelogInput
+ * @returns {Changelog}
+ */
+export function parse(changelogInput) {
+
+  const lines = changelogInput.split('\n');
+  if (!lines[1].match(/^={1,}$/)) {
+    throw new Error('Parse error: Line 1 and 2 of the changelog must be in the format "Changelog\\n=====". We did not find all equals signs on the second line.');
+  }
+  const changelog = new Changelog();
+  changelog.title = lines[0];
+
+  for(let idx=2; idx<lines.length; idx++) {
+
+    if (lines[idx+1]?.match(/^-{1,}$/)) {
+      // Found a new Version
+      const versionTitle = lines[idx];
+      const matches = versionTitle.match(/^([0-9\.]{3,}(?:-(?:alpha|beta)\.[0-9])?) \(([0-9]{4}-[0-9]{2}-[0-9]{2}|\?\?\?\?-\?\?-\?\?)\)$/);
+
+      if (!matches) {
+        throw new Error(`A version title must have the format "1.0.0 (YYYY-MM-DD)" or "1.0.0 (????-??-??)" for unreleased versions. We found: "${lines[idx]}"`);
+      }
+
+      const versionLog = new VersionLog(matches[1]);
+      if (matches[2] === '????-??-??') {
+        versionLog.date = null;
+      } else {
+        versionLog.date = matches[2];
+      }
+      changelog.add(versionLog);
+
+    }
+
+  }
+
+  return changelog;
+
+
+}

package/test/parse.mjs

@@ -0,0 +1,33 @@
+import { test } from 'node:test';
+import { parse } from '../parse.mjs';
+import * as assert from 'node:assert';
+
+test('Parsing a basic changelog', async () => {
+
+  const input = `Time for a change
+=========
+
+0.2.0 (????-??-??)
+------------------
+
+* Implemented the 'list' command.
+* Added testing framework.
+
+0.1.0 (2023-02-08)
+------------------
+
+* Implemented the 'help' and 'init' commands.
+*
+`;
+
+  const result = await parse(input);
+
+  assert.equal('Time for a change', result.title);
+  assert.equal(2, result.versions.length);
+  
+  assert.equal(null, result.versions[0].date);
+  assert.equal('0.2.0', result.versions[0].version);
+  assert.equal('2023-02-08', result.versions[1].date);
+  assert.equal('0.1.0', result.versions[1].version);
+
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "esnext",
+    "rootDir": "./",
+    "allowJs": true,
+    "checkJs": true,
+
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+     
+    "noEmit": true,
+    "strict": true,
+    "useUnknownInCatchVariables": false,
+  
+  }
+}

package/util.mjs

@@ -0,0 +1,76 @@
+// @ts-check
+import * as fs from 'node:fs/promises';
+
+/**
+ * Checks if a file exists
+ *
+ * @param {string} filename
+ * @returns {Promise<boolean>}
+ */
+export async function exists(filename) {
+
+  try {
+  await fs.stat(filename)
+  } catch (err) {
+    if (err.code === 'ENOENT') return false;
+    throw err;
+  }
+  return true;
+
+}
+
+/**
+ * Returns the version property of the package.json file in the current
+ * directory.
+ *
+ * @returns {Promise<string>}
+ */
+export async function readPackageVersion() {
+
+  if (!await exists('package.json')) {
+    throw new Error('package.json does not exists in the current directory');
+  }
+
+  const json = JSON.parse(
+    await fs.readFile(
+      'package.json',
+      'utf-8'
+    )
+  );
+
+  return json.version;
+
+}
+
+/**
+ * Wraps a line over multiple lines.
+ *
+ * @param {string} input
+ * @param {number} secondLineOffset
+ * @param {number} lineLength
+ */
+export function wrap(input, secondLineOffset = 0, lineLength = 80) {
+
+  const words = input.split(' ');
+  const lines = [];
+  for(const word of words) {
+
+    if (!lines.length) {
+      // First line
+      lines.push(word);
+      continue;
+    }
+
+    const maxLength = lines.length > 1 ? lineLength - secondLineOffset : lineLength;
+    
+    const potentialNewLine = [lines.at(-1),word].join(' ');
+    if (potentialNewLine.length>maxLength) {
+      lines.push(word);
+    } else {
+      lines[lines.length-1] = potentialNewLine;
+    }
+
+  }
+  return lines.join('\n' + ' '.repeat(secondLineOffset));
+
+}