@sasjs/utils 4.1.2 → 4.2.0

package/README.md

@@ -20,6 +20,7 @@ import { ServerType } from '@sasjs/utils/types'
 import { prefixMessage } from '@sasjs/utils/error'
 import { isSpecialMissing } from '@sasjs/utils/input/validators'
 import { bytesToSize } from '@sasjs/utils/utils'
+import { parseLog } from '@sasjs/utils/logs'
 ```
 
 The hash and sync helpers - `getHash`, `compareHashes`, `extractHashArray`,
@@ -29,6 +30,20 @@ folders on disk, so they are Node-only, and the barrel does not re-export them:
 bundle that imports the barrel for anything else no longer reaches `crypto`, which used to
 arrive with the whole AES/RSA/ECDSA polyfill suite behind it.
 
+`@sasjs/utils/logs` parses a SAS log: `parseLog(text)` returns every `ERROR`,
+`WARNING` and notable `NOTE` as an issue addressed by line and column, and
+`nextIssue(issues, line, direction)` walks that list for a next/previous problem
+control. It is a pair of pure functions with no imports at all, so it runs
+unchanged in Node, in a browser bundle and in an editor extension, and it lives
+on a subpath so a browser never reaches the barrel's Node dependencies.
+
+Only the notes the log-checking literature chases are reported - an
+uninitialized variable, invalid data, a W.D format too small, values converted to
+another type, repeats of BY values - because a log carries thousands of ordinary
+notes and none of them is what a reader is looking for. The list is
+`NOTE_KEYWORDS` in `src/logs/sasLog.ts`, and adding a keyword is how the scope
+grows.
+
 ## Contributors ✨
 
 Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

package/index.d.ts

@@ -3,6 +3,7 @@ export * from './file';
 export * from './formatter';
 export * from './input';
 export * from './logger';
+export * from './logs';
 export * from './sasjsCli';
 export * from './time';
 export * from './types';

package/index.js

@@ -15,6 +15,7 @@ __exportStar(require("./file"), exports);
 __exportStar(require("./formatter"), exports);
 __exportStar(require("./input"), exports);
 __exportStar(require("./logger"), exports);
+__exportStar(require("./logs"), exports);
 __exportStar(require("./sasjsCli"), exports);
 __exportStar(require("./time"), exports);
 __exportStar(require("./types"), exports);

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAsB;AACtB,yCAAsB;AACtB,8CAA2B;AAC3B,0CAAuB;AACvB,2CAAwB;AACxB,6CAA0B;AAC1B,yCAAsB;AACtB,0CAAuB;AACvB,0CAAuB;AACvB,gDAA6B;AAC7B,yEAAyE;AACzE,6EAA6E;AAC7E,6EAA6E;AAC7E,6EAA6E;AAC7E,4EAA4E;AAC5E,uBAAuB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAsB;AACtB,yCAAsB;AACtB,8CAA2B;AAC3B,0CAAuB;AACvB,2CAAwB;AACxB,yCAAsB;AACtB,6CAA0B;AAC1B,yCAAsB;AACtB,0CAAuB;AACvB,0CAAuB;AACvB,gDAA6B;AAC7B,yEAAyE;AACzE,6EAA6E;AAC7E,6EAA6E;AAC7E,6EAA6E;AAC7E,4EAA4E;AAC5E,uBAAuB"}

package/logs/index.d.ts

@@ -0,0 +1 @@
+export * from './sasLog';

package/logs/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sasLog"), exports);
+//# sourceMappingURL=index.js.map

package/logs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/logs/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAAwB"}

package/logs/sasLog.d.ts

@@ -0,0 +1,87 @@
+/**
+ * SAS log parsing.
+ *
+ * A SAS log is a stream of statements and messages, and only the messages
+ * matter to a reader looking for trouble: everything SAS prints at the start of
+ * a line as `ERROR:`, `WARNING:` or `NOTE:`. This module finds those messages
+ * and reports where they are, as line and column indexes into the text it was
+ * given, so a host can underline them without re-scanning the log and without
+ * rewriting it.
+ *
+ * What is recognised:
+ *
+ *   ERROR: Libref X is not assigned.
+ *   ERROR 22-322: Syntax error, expecting one of the following: ;, CANCEL,
+ *                 RUN, QUIT.
+ *   WARNING 1-322: Assuming the symbol Y was misspelled.
+ *   NOTE: Variable x is uninitialized.
+ *
+ * The numeric code between the marker and the colon is SAS's own message
+ * identifier and is reported separately, so a host can group by it.
+ *
+ * NOTES are reported only when they are the ones the log-checking literature
+ * flags - see NOTE_KEYWORDS. A log carries thousands of ordinary notes and none
+ * of them is what a reader is looking for, so the vocabulary is a closed list
+ * rather than "any NOTE". INFO lines are not reported at all.
+ *
+ * Lines SAS wrapped are folded into the message they belong to, so one problem
+ * is one issue rather than one issue per wrapped line, and the keyword search
+ * runs on the folded message - a note whose keyword lands on the second line is
+ * still found. Lines that merely contain the word ERROR are not matched: the
+ * marker has to start the line, which keeps a print of a data set, or a message
+ * quoting another log, out of the results.
+ *
+ * ODS HTML logs wrap every line in markup. A tag sequence before the marker is
+ * skipped and tags are stripped from the reported message, so the same parse
+ * serves a plain log and an HTML one. The line and column indexes stay those of
+ * the text as supplied, because they are what the caller needs to address.
+ *
+ * Nothing here touches the log: the caller renders from the issue list, which is
+ * what lets one log be shown in an editor, in a browser panel and in a report
+ * from the same parse.
+ */
+/**
+ * The severities a log issue can carry. `note` is only ever a notable note - see
+ * NOTE_KEYWORDS - never an ordinary one.
+ */
+export declare type LogSeverity = 'error' | 'warning' | 'note';
+/** One ERROR, WARNING or notable NOTE in a SAS log, addressed in the text it was parsed from. */
+export interface LogIssue {
+    /** Zero-based index of the line carrying the marker. */
+    line: number;
+    /** Zero-based index of the last line SAS wrapped into this message. */
+    endLine: number;
+    /** Zero-based column where the marker starts on `line`. */
+    column: number;
+    /** Zero-based column one past the end of `line`, for underlining it. */
+    endColumn: number;
+    /** The marker that introduced the issue. */
+    severity: LogSeverity;
+    /** SAS's message identifier, e.g. `22-322` for `ERROR 22-322:`. */
+    code?: string;
+    /** The message text, with wrapped lines joined and markup stripped. */
+    message: string;
+}
+/** Direction of travel for {@link nextIssue}. */
+export declare type IssueDirection = 'next' | 'previous';
+/** Whether a note's message is one of the notable ones. */
+export declare const isNotableNote: (message: string) => boolean;
+/**
+ * Finds every ERROR and WARNING in a SAS log, and every notable note.
+ *
+ * The issue list is in log order. `line` and `column` address the text as
+ * supplied, so a caller can offset a decoration or a diagnostic by them
+ * directly. A host that wants errors only filters on `severity`; nothing is
+ * behind an option, because a notable note is worth reporting wherever the log
+ * is shown.
+ */
+export declare const parseLog: (text: string) => LogIssue[];
+/**
+ * The issue after (or before) a given line, wrapping around, which is the
+ * behaviour both a "next problem" button and a "previous problem" button need.
+ *
+ * A line of -1 starts at the beginning, and a line past the end starts again
+ * from the beginning, so a caller does not have to special-case either end.
+ * Returns undefined only when the log holds no issues.
+ */
+export declare const nextIssue: (issues: LogIssue[], line: number, direction?: IssueDirection) => LogIssue | undefined;

package/logs/sasLog.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * SAS log parsing.
+ *
+ * A SAS log is a stream of statements and messages, and only the messages
+ * matter to a reader looking for trouble: everything SAS prints at the start of
+ * a line as `ERROR:`, `WARNING:` or `NOTE:`. This module finds those messages
+ * and reports where they are, as line and column indexes into the text it was
+ * given, so a host can underline them without re-scanning the log and without
+ * rewriting it.
+ *
+ * What is recognised:
+ *
+ *   ERROR: Libref X is not assigned.
+ *   ERROR 22-322: Syntax error, expecting one of the following: ;, CANCEL,
+ *                 RUN, QUIT.
+ *   WARNING 1-322: Assuming the symbol Y was misspelled.
+ *   NOTE: Variable x is uninitialized.
+ *
+ * The numeric code between the marker and the colon is SAS's own message
+ * identifier and is reported separately, so a host can group by it.
+ *
+ * NOTES are reported only when they are the ones the log-checking literature
+ * flags - see NOTE_KEYWORDS. A log carries thousands of ordinary notes and none
+ * of them is what a reader is looking for, so the vocabulary is a closed list
+ * rather than "any NOTE". INFO lines are not reported at all.
+ *
+ * Lines SAS wrapped are folded into the message they belong to, so one problem
+ * is one issue rather than one issue per wrapped line, and the keyword search
+ * runs on the folded message - a note whose keyword lands on the second line is
+ * still found. Lines that merely contain the word ERROR are not matched: the
+ * marker has to start the line, which keeps a print of a data set, or a message
+ * quoting another log, out of the results.
+ *
+ * ODS HTML logs wrap every line in markup. A tag sequence before the marker is
+ * skipped and tags are stripped from the reported message, so the same parse
+ * serves a plain log and an HTML one. The line and column indexes stay those of
+ * the text as supplied, because they are what the caller needs to address.
+ *
+ * Nothing here touches the log: the caller renders from the issue list, which is
+ * what lets one log be shown in an editor, in a browser panel and in a report
+ * from the same parse.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextIssue = exports.parseLog = exports.isNotableNote = void 0;
+/**
+ * `ERROR`, `WARNING` or `NOTE` at the start of a line, optionally preceded by
+ * the tags of an HTML log, optionally followed by SAS's message identifier,
+ * then a colon. The prefix is captured so the marker's column is exact even when
+ * tags lead it.
+ */
+const MARKER = /^((?:<[^>]*>)*\s*)(ERROR|WARNING|NOTE)(?:\s+(\d+-\d+))?:[ \t]?(.*)$/i;
+/**
+ * The notes worth reporting, matched case-insensitively against the folded
+ * message. Each is a message SAS prints when something has gone wrong quietly -
+ * a variable never set, a row that failed input, a value silently converted, a
+ * format too small to hold a number - and each is chased by the log checkers
+ * published in the SAS user-group papers: "Log Checks Made Easy" (SAS Global
+ * Forum 2012, 042-2012), "Check Please: An Automated Approach to Log Checking"
+ * (MWSUG 2017, TT02), "You've Got E-Mail: Automatic Log Checking via E-Mail
+ * Notification" (SUGI 31, 128-31) and the note table behind SASLogChecker.
+ *
+ * Adding a keyword widens what every host reports, so the list is deliberately
+ * short: a message belongs here when a reviewer would want to see it even though
+ * SAS called it a note.
+ */
+const NOTE_KEYWORDS = [
+    'is uninitialized',
+    'Missing values were generated',
+    'Division by zero',
+    'Mathematical operations could not be performed',
+    'Invalid data',
+    'Invalid argument',
+    'Invalid third argument',
+    'have been converted to',
+    'The meaning of an identifier',
+    'too small for',
+    'Unreferenced label',
+    'WHERE clause has been replaced',
+    'stopped due to looping',
+    'will be overwritten by data set',
+    'repeats of BY values',
+    'was not found',
+    'reached past the end of a line',
+    'LOST CARD',
+    'NOEXEC',
+    'A CASE expression has no ELSE clause',
+    'have been thinned',
+    'discarded because neither',
+    'Processing on disk occurred during summarization',
+    'log axis cannot support',
+    'lines were truncated',
+    'outside the axis range',
+    'infinite likelihood',
+    'not positive definite',
+    'The SAS System stopped processing this step because of errors'
+];
+const NOTABLE_NOTE_KEYWORDS = NOTE_KEYWORDS.map((keyword) => keyword.toLowerCase());
+/** How many wrapped lines one message may absorb, so a malformed log cannot run away. */
+const MAX_WRAPPED_LINES = 10;
+/** Whether a note's message is one of the notable ones. */
+const isNotableNote = (message) => {
+    const lower = message.toLowerCase();
+    return NOTABLE_NOTE_KEYWORDS.some((keyword) => lower.includes(keyword));
+};
+exports.isNotableNote = isNotableNote;
+/** A line SAS wrapped: indented, and not one of the pointer lines it prints under source. */
+const isWrappedLine = (line) => /^\s+\S/.test(line) &&
+    !/^\s*[-_]+\s*$/.test(line) &&
+    !/^\s*\d+\s*$/.test(line);
+/** Removes markup and collapses the whitespace a wrapped message carries. */
+const clean = (text) => text
+    .replace(/<[^>]*>/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+/**
+ * Finds every ERROR and WARNING in a SAS log, and every notable note.
+ *
+ * The issue list is in log order. `line` and `column` address the text as
+ * supplied, so a caller can offset a decoration or a diagnostic by them
+ * directly. A host that wants errors only filters on `severity`; nothing is
+ * behind an option, because a notable note is worth reporting wherever the log
+ * is shown.
+ */
+const parseLog = (text) => {
+    var _a;
+    if (!text) {
+        return [];
+    }
+    const lines = text.split(/\r?\n/);
+    const issues = [];
+    for (let line = 0; line < lines.length; line++) {
+        const match = MARKER.exec(lines[line]);
+        if (!match) {
+            continue;
+        }
+        const markerLine = line;
+        const parts = [clean((_a = match[4]) !== null && _a !== void 0 ? _a : '')];
+        let endLine = markerLine;
+        let wrapped = 0;
+        while (wrapped < MAX_WRAPPED_LINES &&
+            endLine + 1 < lines.length &&
+            isWrappedLine(lines[endLine + 1])) {
+            endLine++;
+            wrapped++;
+            parts.push(clean(lines[endLine]));
+        }
+        const severity = match[2].toLowerCase();
+        const message = parts.filter((part) => part !== '').join(' ');
+        // The wrapped lines belong to this message whether or not it is reported, so
+        // the scan resumes after them either way.
+        line = endLine;
+        if (severity === 'note' && !(0, exports.isNotableNote)(message)) {
+            continue;
+        }
+        const code = match[3];
+        issues.push(Object.assign(Object.assign({ line: markerLine, endLine, column: match[1].length, endColumn: lines[markerLine].length, severity }, (code ? { code } : {})), { message }));
+    }
+    return issues;
+};
+exports.parseLog = parseLog;
+/**
+ * The issue after (or before) a given line, wrapping around, which is the
+ * behaviour both a "next problem" button and a "previous problem" button need.
+ *
+ * A line of -1 starts at the beginning, and a line past the end starts again
+ * from the beginning, so a caller does not have to special-case either end.
+ * Returns undefined only when the log holds no issues.
+ */
+const nextIssue = (issues, line, direction = 'next') => {
+    var _a;
+    if (issues.length === 0) {
+        return undefined;
+    }
+    if (direction === 'next') {
+        return (_a = issues.find((issue) => issue.line > line)) !== null && _a !== void 0 ? _a : issues[0];
+    }
+    for (let index = issues.length - 1; index >= 0; index--) {
+        if (issues[index].line < line) {
+            return issues[index];
+        }
+    }
+    return issues[issues.length - 1];
+};
+exports.nextIssue = nextIssue;
+//# sourceMappingURL=sasLog.js.map

package/logs/sasLog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sasLog.js","sourceRoot":"","sources":["../../src/logs/sasLog.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -46,6 +46,7 @@
     "fs/**",
     "input/**",
     "logger/**",
+    "logs/**",
     "macros/**",
     "sasjsCli/**",
     "time/**",
@@ -95,5 +96,5 @@
     "jwt-decode": "4.0.0",
     "prompts": "2.4.2"
   },
-  "version": "4.1.2"
+  "version": "4.2.0"
 }