keep-a-changelog 0.10.4 → 2.0.0-beta

package/src/Release.js

@@ -1,220 +0,0 @@
-const Semver = require('semver/classes/semver');
-const Change = require('./Change');
-
-class Release {
-    constructor(version, date, description = '') {
-        this.setVersion(version);
-        this.setDate(date);
-
-        this.description = description;
-        this.changes = new Map([
-            ['added', []],
-            ['changed', []],
-            ['deprecated', []],
-            ['removed', []],
-            ['fixed', []],
-            ['security', []],
-        ]);
-    }
-
-    compare(release) {
-        if (!this.version && release.version) {
-            return -1;
-        }
-
-        if (!release.version) {
-            return 1;
-        }
-
-        if (!this.date && release.date) {
-            return -1;
-        }
-
-        if (!release.date) {
-            return 1;
-        }
-
-        return -this.version.compare(release.version);
-    }
-
-    isEmpty() {
-        if (this.description.trim()) {
-            return false;
-        }
-
-        return Array.from(this.changes.values()).every((change) => !change.length);
-    }
-
-    setVersion(version) {
-        if (typeof version === 'string') {
-            version = new Semver(version);
-        }
-        this.version = version;
-        //Re-sort the releases of the parent changelog
-        if (this.changelog) {
-            this.changelog.sortReleases();
-        }
-    }
-
-    setDate(date) {
-        if (typeof date === 'string') {
-            date = new Date(date);
-        }
-        this.date = date;
-    }
-
-    addChange(type, change) {
-        if (!(change instanceof Change)) {
-            change = new Change(change);
-        }
-
-        if (!this.changes.has(type)) {
-            throw new Error('Invalid change type');
-        }
-
-        this.changes.get(type).push(change);
-
-        return this;
-    }
-
-    added(change) {
-        return this.addChange('added', change);
-    }
-
-    changed(change) {
-        return this.addChange('changed', change);
-    }
-
-    deprecated(change) {
-        return this.addChange('deprecated', change);
-    }
-
-    removed(change) {
-        return this.addChange('removed', change);
-    }
-
-    fixed(change) {
-        return this.addChange('fixed', change);
-    }
-
-    security(change) {
-        return this.addChange('security', change);
-    }
-
-    toString(changelog) {
-        let t = [];
-
-        if (this.version) {
-            if (this.hasCompareLink(changelog)) {
-                t.push(`## [${this.version}] - ${formatDate(this.date)}`);
-            } else {
-                t.push(`## ${this.version} - ${formatDate(this.date)}`);
-            }
-        } else {
-            if (this.hasCompareLink(changelog)) {
-                t.push('## [Unreleased]');
-            } else {
-                t.push('## Unreleased');
-            }
-        }
-
-        if (this.description.trim()) {
-            t.push(this.description.trim());
-            t.push('');
-        }
-
-        this.changes.forEach((changes, type) => {
-            if (changes.length) {
-                t.push(`### ${type[0].toUpperCase()}${type.substring(1)}`);
-                t = t.concat(changes.map((change) => change.toString()));
-                t.push('');
-            }
-        });
-
-        return t.join('\n').trim();
-    }
-
-    getCompareLink(changelog) {
-        if (!this.hasCompareLink(changelog)) {
-            return;
-        }
-
-        const index = changelog.releases.indexOf(this);
-
-        let offset = 1;
-        let previous = changelog.releases[index + offset];
-
-        while (!previous.date) {
-            ++offset;
-            previous = changelog.releases[index + offset];
-        }
-
-        if (!this.version) {
-            return `[Unreleased]: ${changelog.url}/compare/${changelog.tagName(previous)}...${
-                changelog.head
-            }`;
-        }
-
-        if (!this.date) {
-            return `[${this.version}]: ${changelog.url}/compare/${changelog.tagName(previous)}...${
-                changelog.head
-            }`;
-        }
-
-        return `[${this.version}]: ${changelog.url}/compare/${changelog.tagName(
-            previous
-        )}...${changelog.tagName(this)}`;
-    }
-
-    getLinks(changelog) {
-        const links = [];
-
-        if (!changelog.url) {
-            return links;
-        }
-
-        this.changes.forEach((changes) =>
-            changes.forEach((change) => {
-                change.issues.forEach((issue) => {
-                    if (!links.includes(issue)) {
-                        links.push(`[#${issue}]: ${changelog.url}/issues/${issue}`);
-                    }
-                });
-            })
-        );
-
-        return links;
-    }
-
-    hasCompareLink(changelog) {
-        if (!changelog || !changelog.url || !changelog.releases.length) {
-            return false;
-        }
-
-        const index = changelog.releases.indexOf(this);
-        const next = changelog.releases[index + 1];
-
-        return next && next.version && next.date;
-    }
-}
-
-module.exports = Release;
-
-function formatDate(date) {
-    if (!date) {
-        return 'Unreleased';
-    }
-
-    let year = date.getUTCFullYear(),
-        month = date.getUTCMonth() + 1,
-        day = date.getUTCDate();
-
-    if (month < 10) {
-        month = '0' + month;
-    }
-    if (day < 10) {
-        day = '0' + day;
-    }
-
-    return `${year}-${month}-${day}`;
-}

package/src/index.js

@@ -1,6 +0,0 @@
-module.exports = {
-    parser: require('./parser'),
-    Change: require('./Change'),
-    Changelog: require('./Changelog'),
-    Release: require('./Release'),
-};

package/src/parser.js

@@ -1,182 +0,0 @@
-const Changelog = require('./Changelog');
-const Release = require('./Release');
-
-const defaultOptions = {
-    releaseCreator: (version, date, description) => new Release(version, date, description),
-};
-
-module.exports = function parser(markdown, options) {
-    const opts = Object.assign({}, defaultOptions, options);
-    const tokens = tokenize(markdown);
-
-    try {
-        return parseTokens(tokens, opts);
-    } catch (error) {
-        throw new Error(`Parse error in the line ${tokens[0][0]}: ${error.message}`);
-    }
-};
-
-function parseTokens(tokens, opts) {
-    const changelog = new Changelog();
-
-    changelog.title = getContent(tokens, 'h1', true);
-    changelog.description = getContent(tokens, 'p');
-
-    //Releases
-    let release;
-
-    while ((release = getContent(tokens, 'h2').toLowerCase())) {
-        const matches = release.match(/\[?([^\]]+)\]?\s*-\s*([\d]{4}-[\d]{1,2}-[\d]{1,2})$/);
-
-        if (matches) {
-            release = opts.releaseCreator(matches[1], matches[2]);
-        } else if (release.includes('unreleased')) {
-            const matches = release.match(/\[?([^\]]+)\]?\s*-\s*unreleased$/);
-            release = matches ? opts.releaseCreator(matches[1]) : opts.releaseCreator();
-        } else {
-            throw new Error(`Syntax error in the release title`);
-        }
-
-        changelog.addRelease(release);
-        release.description = getContent(tokens, 'p');
-
-        let type;
-
-        while ((type = getContent(tokens, 'h3').toLowerCase())) {
-            let change;
-
-            while ((change = getContent(tokens, 'li'))) {
-                release.addChange(type, change);
-            }
-        }
-    }
-
-    //Skip release links
-    let link = getContent(tokens, 'link');
-
-    while (link) {
-        if (!changelog.url) {
-            const matches = link.match(/^\[.*\]\:\s*(http.*)\/compare\/.*$/);
-
-            if (matches) {
-                changelog.url = matches[1];
-            }
-        }
-
-        link = getContent(tokens, 'link');
-    }
-
-    //Footer
-    if (getContent(tokens, 'hr')) {
-        changelog.footer = getContent(tokens, 'p');
-    }
-
-    if (tokens.length) {
-        throw new Error(`Unexpected content ${JSON.stringify(tokens)}`);
-    }
-
-    return changelog;
-}
-
-function getContent(tokens, type, required = false) {
-    if (!tokens[0] || tokens[0][1] !== type) {
-        if (required) {
-            throw new Error(`Required token missing in: "${tokens[0][0]}"`);
-        }
-
-        return '';
-    }
-
-    return tokens.shift()[2].join('\n');
-}
-
-function tokenize(markdown) {
-    const tokens = [];
-
-    markdown
-        .trim()
-        .split('\n')
-        .map((line, index, allLines) => {
-            if (line.startsWith('---')) {
-                return ['hr', ['-']];
-            }
-
-            if (line.startsWith('# ')) {
-                return ['h1', [line.substr(1).trim()]];
-            }
-
-            if (line.startsWith('## ')) {
-                return ['h2', [line.substr(2).trim()]];
-            }
-
-            if (line.startsWith('### ')) {
-                return ['h3', [line.substr(3).trim()]];
-            }
-
-            if (line.startsWith('-')) {
-                return ['li', [line.substr(1).trim()]];
-            }
-
-            if (line.startsWith('*')) {
-                return ['li', [line.substr(1).trim()]];
-            }
-
-            if (line.match(/^\[.*\]\:\s*http.*$/)) {
-                return ['link', [line.trim()]];
-            }
-            if (line.match(/^\[.*\]\:$/)) {
-                const nextLine = allLines[index + 1];
-                if (nextLine && nextLine.match(/\s+http.*$/)) {
-                    // We found a multi-line link: treat it like a single line
-                    allLines[index + 1] = '';
-                    return ['link', [line.trim() + '\n' + nextLine.trimEnd()]];
-                }
-            }
-
-            return ['p', [line.trimEnd()]];
-        })
-        .forEach((line, index) => {
-            const [type, [content]] = line;
-
-            if (index > 0) {
-                const prevType = tokens[0][1];
-
-                if (type === 'p') {
-                    if (prevType === 'p') {
-                        return tokens[0][2].push(content);
-                    }
-
-                    if (prevType === 'li') {
-                        return tokens[0][2].push(content.replace(/^\s\s/, ''));
-                    }
-                }
-            }
-
-            tokens.unshift([index + 1, type, [content]]);
-        });
-
-    return tokens
-        .filter((token) => !isEmpty(token[2]))
-        .map((token) => {
-            const content = token[2];
-
-            while (isEmpty(content[content.length - 1])) {
-                content.pop();
-            }
-
-            while (isEmpty(content[0])) {
-                content.shift();
-            }
-
-            return token;
-        })
-        .reverse();
-}
-
-function isEmpty(val) {
-    if (Array.isArray(val)) {
-        val = val.join('');
-    }
-
-    return !val || val.trim() === '';
-}