contensis-cli 1.0.12-beta.2 → 1.0.12-beta.21

package/src/util/git.ts

@@ -75,7 +75,7 @@ export class GitHelper {
   }
   gitcwd = () => path.join(this.gitRepoPath);
   gitInfo = (url: string = this.originUrl) => hostedGitInfo.fromUrl(url);
-  hostType = (url: string = this.originUrl): GitTypes => {
+  hostType = (url: string = this.originUrl): GitTypes | undefined => {
     if (url) {
       if (url.includes('github.com')) return 'github';
       else return 'gitlab';
@@ -87,6 +87,7 @@ export class GitHelper {
   gitConfig = (cwd = this.gitRepoPath) => {
     // Find .git/config in project cwd
     const config = parseGitConfig.sync({
+      cwd,
       path: '.git/config',
       expandKeys: true,
     });

package/src/util/json.formatter.ts

@@ -1 +1,32 @@
-export const jsonFormatter = <T>(obj: T) => JSON.stringify(obj, null, 2);
+import { flatten, unflatten } from 'flat';
+import cleaner from 'deep-cleaner';
+
+// Format a JSON object for a nice output
+export const jsonFormatter = <T>(obj: T, fields?: string[]) =>
+  JSON.stringify(limitFields(obj, fields), null, 2);
+
+// Flatten a JSON object such as an entry so there are no
+// nested object and the keys are presented like "sys.version.versionNo": "1.0"
+export const flattenObject = (obj: any) => flatten(cleaner(obj, ['workflow']));
+
+// Will limit and sort an object's keys by an array of supplied fields
+export const limitFields = (obj: any, fields?: string[]): any => {
+  if (!fields) return obj;
+  if (obj && Array.isArray(obj)) {
+    const arr = [];
+    for (const child of obj) arr.push(limitFields(child, fields));
+    return arr;
+  }
+
+  if (obj && typeof obj === 'object') {
+    const flattenedObj = flatten(obj) as any;
+    const sortedObj = {} as any;
+    for (const field of fields) {
+      sortedObj[field] = flattenedObj[field];
+    }
+
+    return unflatten(sortedObj);
+  }
+
+  return obj;
+};

package/src/util/logger.ts

@@ -2,7 +2,12 @@
 import chalk from 'chalk';
 import dateFormat from 'dateformat';
 import deepCleaner from 'deep-cleaner';
-import { ansiEscapeCodes, first, strlen } from 'printable-characters';
+import {
+  ansiEscapeCodes,
+  first,
+  partition,
+  strlen,
+} from 'printable-characters';
 // import ProgressBar from 'progress';
 import { isSysError, tryStringify } from '.';
 
@@ -225,24 +230,41 @@ export class Logger {
     else console.log(content);
   };
 
-  static limits = (content: string, displayLength = 30) => {
-    const consoleWidth = process.stdout.columns;
-    console.info(
-      consoleWidth
-        ? content
-            .split('\n')
-            .slice(0, consoleWidth ? displayLength : undefined)
-            .map((line: string) =>
-              consoleWidth && strlen(line) > consoleWidth
-                ? first(line, consoleWidth)
-                : line
+  static limits = (
+    content: string,
+    displayLength = 30,
+    consoleWidth = process.stdout.columns,
+    logMethod: Function = console.info
+  ) => {
+    if (consoleWidth) {
+      const contentArray = content.endsWith('\n')
+        ? content.split('\n').slice(0, -1)
+        : content.split('\n');
+      const contentLines = contentArray.slice(
+        0,
+        consoleWidth ? displayLength : undefined
+      );
+      for (const line of contentLines)
+        logMethod(
+          line
+            .split('~n')
+            .map(l =>
+              consoleWidth && strlen(l) > consoleWidth
+                ? first(l, consoleWidth)
+                : l
             )
             .join('\n')
-        : content.replace(ansiEscapeCodes, '')
-    );
+        );
+    } else {
+      logMethod(content.replace(ansiEscapeCodes, '').replaceAll('~n', '\n'));
+    }
+
     const tableArray = content.split('\n');
     if (consoleWidth && tableArray.length > displayLength)
-      console.info(`\n`, `- and ${tableArray.length - displayLength} more...`);
+      console.info(
+        `\n`,
+        `- and ${tableArray.length - displayLength} more...\n`
+      );
   };
 }
 
@@ -265,6 +287,59 @@ export const logError: LogErrorFunc = (
   return null;
 };
 
+export const addNewLines = (
+  message = '',
+  newLineSeparater = '\n',
+  atPosition = process.stdout.columns
+) => {
+  if (message === '' || atPosition === 0) {
+    return '';
+  }
+
+  let result = '';
+  let lengthCounter = 0;
+
+  // Partition the message string into an array of
+  // [nonPrintable, printable][]
+  const partitioned = partition(message);
+  const addSeparater = () => {
+    // If line length counter has exceeded the console width
+    // add a new line separater and reset the line length counter
+    if (lengthCounter >= atPosition) {
+      result += newLineSeparater;
+      lengthCounter = 0;
+    }
+  };
+
+  // Loop through the partitioned message parts
+  for (const [nonPrintable, printable] of partitioned) {
+    // Convert string to array as this will provide accurate
+    // lengths and splicing methods with all unicode chars
+    const textParts = Array.from(printable);
+    // Splice the remaining allowable line length from the text parts array
+    const text = textParts.splice(0, atPosition - lengthCounter);
+    // In the first iteration append the non printable unicode chars
+    // to the beginning of the spliced text
+    result += nonPrintable + text.join('');
+    // Keep a count of the current line length
+    // as one line of output could span multiple "partitions"
+    lengthCounter += text.length;
+    addSeparater();
+
+    // Handle any remaining text in this "partition"
+    while (textParts.length) {
+      // Splice the remaining allowable line length from the text parts array
+      const text = textParts.splice(0, atPosition - lengthCounter);
+      // Append the spliced text to the result
+      result += text.join('');
+      // Increase line length counter
+      lengthCounter += text.length;
+      addSeparater();
+    }
+  }
+  return result;
+};
+
 export const progress = {
   current: { interrupt: (x: string) => {} },
   active: false,

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "1.0.12-beta.2";
+export const LIB_VERSION = "1.0.12-beta.21";