@aws-cdk/cloudformation-diff 0.0.0

package/lib/format-table.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTable = formatTable;
+const chalk = require("chalk");
+const string_width_1 = require("string-width");
+const table = require("table");
+/**
+ * Render a two-dimensional array to a visually attractive table
+ *
+ * First row is considered the table header.
+ */
+function formatTable(cells, columns) {
+    return table.table(cells, {
+        border: TABLE_BORDER_CHARACTERS,
+        columns: buildColumnConfig(columns !== undefined ? calculateColumnWidths(cells, columns) : undefined),
+        drawHorizontalLine: (line) => {
+            // Numbering like this: [line 0] [header = row[0]] [line 1] [row 1] [line 2] [content 2] [line 3]
+            return (line < 2 || line === cells.length) || lineBetween(cells[line - 1], cells[line]);
+        },
+    }).trimRight();
+}
+/**
+ * Whether we should draw a line between two rows
+ *
+ * Draw horizontal line if 2nd column values are different.
+ */
+function lineBetween(rowA, rowB) {
+    return rowA[1] !== rowB[1];
+}
+function buildColumnConfig(widths) {
+    if (widths === undefined) {
+        return undefined;
+    }
+    const ret = {};
+    widths.forEach((width, i) => {
+        if (width === undefined) {
+            return;
+        }
+        ret[i] = { width };
+    });
+    return ret;
+}
+/**
+ * Calculate column widths given a terminal width
+ *
+ * We do this by calculating a fair share for every column. Extra width smaller
+ * than the fair share is evenly distributed over all columns that exceed their
+ * fair share.
+ */
+function calculateColumnWidths(rows, terminalWidth) {
+    // The terminal is sometimes reported to be 0. Also if the terminal is VERY narrow,
+    // just assume a reasonable minimum size.
+    terminalWidth = Math.max(terminalWidth, 40);
+    // use 'string-width' to not count ANSI chars as actual character width
+    const columns = rows[0].map((_, i) => Math.max(...rows.map(row => (0, string_width_1.default)(String(row[i])))));
+    // If we have no terminal width, do nothing
+    const contentWidth = terminalWidth - 2 - columns.length * 3;
+    // If we don't exceed the terminal width, do nothing
+    if (sum(columns) <= contentWidth) {
+        return columns;
+    }
+    const fairShare = Math.min(contentWidth / columns.length);
+    const smallColumns = columns.filter(w => w < fairShare);
+    let distributableWidth = contentWidth - sum(smallColumns);
+    const fairDistributable = Math.floor(distributableWidth / (columns.length - smallColumns.length));
+    const ret = new Array();
+    for (const requestedWidth of columns) {
+        if (requestedWidth < fairShare) {
+            // Small column gets what they want
+            ret.push(requestedWidth);
+        }
+        else {
+            // Last column gets all remaining, otherwise get fair redist share
+            const width = distributableWidth < 2 * fairDistributable ? distributableWidth : fairDistributable;
+            ret.push(width);
+            distributableWidth -= width;
+        }
+    }
+    return ret;
+}
+function sum(xs) {
+    let total = 0;
+    for (const x of xs) {
+        total += x;
+    }
+    return total;
+}
+// What color the table is going to be
+const tableColor = chalk.gray;
+// Unicode table characters with a color
+const TABLE_BORDER_CHARACTERS = {
+    topBody: tableColor('─'),
+    topJoin: tableColor('┬'),
+    topLeft: tableColor('┌'),
+    topRight: tableColor('┐'),
+    bottomBody: tableColor('─'),
+    bottomJoin: tableColor('┴'),
+    bottomLeft: tableColor('└'),
+    bottomRight: tableColor('┘'),
+    bodyLeft: tableColor('│'),
+    bodyRight: tableColor('│'),
+    bodyJoin: tableColor('│'),
+    joinBody: tableColor('─'),
+    joinLeft: tableColor('├'),
+    joinRight: tableColor('┤'),
+    joinJoin: tableColor('┼'),
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format-table.js","sourceRoot":"","sources":["format-table.ts"],"names":[],"mappings":"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","sourcesContent":["import * as chalk from 'chalk';\nimport stringWidth from 'string-width';\nimport * as table from 'table';\n\n/**\n * Render a two-dimensional array to a visually attractive table\n *\n * First row is considered the table header.\n */\nexport function formatTable(cells: string[][], columns: number | undefined): string {\n  return table.table(cells, {\n    border: TABLE_BORDER_CHARACTERS,\n    columns: buildColumnConfig(columns !== undefined ? calculateColumnWidths(cells, columns) : undefined),\n    drawHorizontalLine: (line) => {\n      // Numbering like this: [line 0] [header = row[0]] [line 1] [row 1] [line 2] [content 2] [line 3]\n      return (line < 2 || line === cells.length) || lineBetween(cells[line - 1], cells[line]);\n    },\n  }).trimRight();\n}\n\n/**\n * Whether we should draw a line between two rows\n *\n * Draw horizontal line if 2nd column values are different.\n */\nfunction lineBetween(rowA: string[], rowB: string[]) {\n  return rowA[1] !== rowB[1];\n}\n\nfunction buildColumnConfig(widths: number[] | undefined): { [index: number]: table.ColumnUserConfig } | undefined {\n  if (widths === undefined) { return undefined; }\n\n  const ret: { [index: number]: table.ColumnUserConfig } = {};\n  widths.forEach((width, i) => {\n    if (width === undefined) {\n      return;\n    }\n    ret[i] = { width };\n  });\n\n  return ret;\n}\n\n/**\n * Calculate column widths given a terminal width\n *\n * We do this by calculating a fair share for every column. Extra width smaller\n * than the fair share is evenly distributed over all columns that exceed their\n * fair share.\n */\nfunction calculateColumnWidths(rows: string[][], terminalWidth: number): number[] {\n  // The terminal is sometimes reported to be 0. Also if the terminal is VERY narrow,\n  // just assume a reasonable minimum size.\n  terminalWidth = Math.max(terminalWidth, 40);\n\n  // use 'string-width' to not count ANSI chars as actual character width\n  const columns = rows[0].map((_, i) => Math.max(...rows.map(row => stringWidth(String(row[i])))));\n\n  // If we have no terminal width, do nothing\n  const contentWidth = terminalWidth - 2 - columns.length * 3;\n\n  // If we don't exceed the terminal width, do nothing\n  if (sum(columns) <= contentWidth) { return columns; }\n\n  const fairShare = Math.min(contentWidth / columns.length);\n  const smallColumns = columns.filter(w => w < fairShare);\n\n  let distributableWidth = contentWidth - sum(smallColumns);\n  const fairDistributable = Math.floor(distributableWidth / (columns.length - smallColumns.length));\n\n  const ret = new Array<number>();\n  for (const requestedWidth of columns) {\n    if (requestedWidth < fairShare) {\n      // Small column gets what they want\n      ret.push(requestedWidth);\n    } else {\n      // Last column gets all remaining, otherwise get fair redist share\n      const width = distributableWidth < 2 * fairDistributable ? distributableWidth : fairDistributable;\n      ret.push(width);\n      distributableWidth -= width;\n    }\n  }\n\n  return ret;\n}\n\nfunction sum(xs: number[]): number {\n  let total = 0;\n  for (const x of xs) {\n    total += x;\n  }\n  return total;\n}\n\n// What color the table is going to be\nconst tableColor = chalk.gray;\n\n// Unicode table characters with a color\nconst TABLE_BORDER_CHARACTERS = {\n  topBody: tableColor('─'),\n  topJoin: tableColor('┬'),\n  topLeft: tableColor('┌'),\n  topRight: tableColor('┐'),\n  bottomBody: tableColor('─'),\n  bottomJoin: tableColor('┴'),\n  bottomLeft: tableColor('└'),\n  bottomRight: tableColor('┘'),\n  bodyLeft: tableColor('│'),\n  bodyRight: tableColor('│'),\n  bodyJoin: tableColor('│'),\n  joinBody: tableColor('─'),\n  joinLeft: tableColor('├'),\n  joinRight: tableColor('┤'),\n  joinJoin: tableColor('┼'),\n};\n"]}

package/lib/format.d.ts

@@ -0,0 +1,106 @@
+import { DifferenceCollection, TemplateDiff } from './diff/types';
+import { Difference, ResourceDifference, ResourceImpact } from './diff-template';
+import { IamChanges } from './iam/iam-changes';
+import { SecurityGroupChanges } from './network/security-group-changes';
+export interface FormatStream extends NodeJS.WritableStream {
+    columns?: number;
+}
+/**
+ * Renders template differences to the process' console.
+ *
+ * @param stream           The IO stream where to output the rendered diff.
+ * @param templateDiff     TemplateDiff to be rendered to the console.
+ * @param logicalToPathMap A map from logical ID to construct path. Useful in
+ *                         case there is no aws:cdk:path metadata in the template.
+ * @param context          the number of context lines to use in arbitrary JSON diff (defaults to 3).
+ */
+export declare function formatDifferences(stream: FormatStream, templateDiff: TemplateDiff, logicalToPathMap?: {
+    [logicalId: string]: string;
+}, context?: number): void;
+/**
+ * Renders a diff of security changes to the given stream
+ */
+export declare function formatSecurityChanges(stream: NodeJS.WritableStream, templateDiff: TemplateDiff, logicalToPathMap?: {
+    [logicalId: string]: string;
+}, context?: number): void;
+export declare class Formatter {
+    private readonly stream;
+    private readonly logicalToPathMap;
+    private readonly context;
+    constructor(stream: FormatStream, logicalToPathMap: {
+        [logicalId: string]: string;
+    }, diff?: TemplateDiff, context?: number);
+    print(fmt: string, ...args: any[]): void;
+    warning(fmt: string, ...args: any[]): void;
+    formatSection<V, T extends Difference<V>>(title: string, entryType: string, collection: DifferenceCollection<V, T>, formatter?: (type: string, id: string, diff: T) => void): void;
+    printSectionHeader(title: string): void;
+    printSectionFooter(): void;
+    /**
+     * Print a simple difference for a given named entity.
+     *
+     * @param logicalId the name of the entity that is different.
+     * @param diff the difference to be rendered.
+     */
+    formatDifference(type: string, logicalId: string, diff: Difference<any> | undefined): void;
+    /**
+     * Print a resource difference for a given logical ID.
+     *
+     * @param logicalId the logical ID of the resource that changed.
+     * @param diff      the change to be rendered.
+     */
+    formatResourceDifference(_type: string, logicalId: string, diff: ResourceDifference): void;
+    formatResourcePrefix(diff: ResourceDifference): string;
+    formatPrefix<T>(diff: Difference<T>): string;
+    /**
+     * @param value the value to be formatted.
+     * @param color the color to be used.
+     *
+     * @returns the formatted string, with color applied.
+     */
+    formatValue(value: any, color: (str: string) => string): string | undefined;
+    /**
+     * @param impact the impact to be formatted
+     * @returns a user-friendly, colored string representing the impact.
+     */
+    formatImpact(impact: ResourceImpact): string;
+    /**
+     * Renders a tree of differences under a particular name.
+     * @param name    the name of the root of the tree.
+     * @param diff    the difference on the tree.
+     * @param last    whether this is the last node of a parent tree.
+     */
+    formatTreeDiff(name: string, diff: Difference<any>, last: boolean): void;
+    /**
+     * Renders the difference between two objects, looking for the differences as deep as possible,
+     * and rendering a tree graph of the path until the difference is found.
+     *
+     * @param oldObject  the old object.
+     * @param newObject  the new object.
+     * @param linePrefix a prefix (indent-like) to be used on every line.
+     */
+    formatObjectDiff(oldObject: any, newObject: any, linePrefix: string): void;
+    /**
+     * @param oldValue the old value of a difference.
+     * @param newValue the new value of a difference.
+     *
+     * @returns a tag to be rendered in the diff, reflecting whether the difference
+     *      was an ADDITION, UPDATE or REMOVAL.
+     */
+    changeTag(oldValue: any | undefined, newValue: any | undefined): string;
+    /**
+     * Find 'aws:cdk:path' metadata in the diff and add it to the logicalToPathMap
+     *
+     * There are multiple sources of logicalID -> path mappings: synth metadata
+     * and resource metadata, and we combine all sources into a single map.
+     */
+    readConstructPathsFrom(templateDiff: TemplateDiff): void;
+    formatLogicalId(logicalId: string): string;
+    normalizedLogicalIdPath(logicalId: string): string | undefined;
+    formatIamChanges(changes: IamChanges): void;
+    formatSecurityGroupChanges(changes: SecurityGroupChanges): void;
+    deepSubstituteBracedLogicalIds(rows: string[][]): string[][];
+    /**
+     * Substitute all strings like ${LogId.xxx} with the path instead of the logical ID
+     */
+    substituteBracedLogicalIds(source: string): string;
+}