analogger 1.2.0 → 1.3.0

package/.eslintrc.cjs

@@ -0,0 +1,25 @@
+module.exports = {
+    env: {
+        browser: true,
+        node: true
+    },
+    parser: "@babel/eslint-parser",
+    parserOptions: {
+        "ecmaVersion": 2020
+    },
+    rules: {
+        "comma-dangle": 0,
+        "comma-style": ["error", "last"],
+        "no-bitwise": "off",
+        "no-console": "off",
+        "no-nested-ternary": "off",
+        "no-plusplus": "off",
+        "prefer-const": "off",
+        "spaced-comment": "off",
+        "no-debugger": "error",
+        "quotes": ["error", "double"],
+        "semi": 2,
+        "no-unused-vars": "error",
+        "max-len": ["error", {code: 200}]
+    }
+};

package/.github/workflows/test.yml

@@ -0,0 +1,24 @@
+name: Versioning AnaLogger
+env:
+  ANALOGGER_APP_NAME: "release/analogger"
+on:
+  push:
+    branches:
+      - "**"
+    paths-ignore:
+      - "**.md"
+      - ".vscode/**"
+jobs:
+  set-version:
+    runs-on: [self-hosted]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Check out Git repository
+        uses: thimpat/analogger/.github/actions/checkout@ci
+      - name: Install dependencies
+        shell: powershell
+        run: npm install
+      - name: Test
+        shell: powershell
+        run: |
+          npm test

package/.github/workflows/versioning.yml

@@ -23,5 +23,3 @@ jobs:
         shell: powershell
         run: |
           npx semantic-release
-      - name: Versioning successful
-        run: echo "Success"

package/.releaserc

@@ -0,0 +1,27 @@
+{
+  "branches": ["test", "main",  "next"],
+  "dryRun": false,
+  "ci": true,
+  "debug": true,
+  "plugins": [
+      ["@semantic-release/commit-analyzer",
+      {
+        "preset": "angular",
+        "releaseRules": [
+        {"type": "docs", "scope":"README", "release": "patch"},
+        {"type": "refactor", "release": "patch"},
+        {"type": "style", "release": "patch"}
+        ],
+        "parserOpts": {
+        "noteKeywords": ["BREAKING CHANGE", "BREAKING CHANGES"]
+        }
+      }],
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      ["@semantic-release/git", {
+        "assets": ["package.json", "CHANGELOG.md"],
+        "message": "AnaLogger Release: ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+      }]
+    ]
+}

package/CHANGELOG.md

@@ -0,0 +1 @@
+# [1.3.0](https://github.com/thimpat/analogger/compare/v1.2.0...v1.3.0) (2022-02-08)

package/README.md

@@ -169,3 +169,22 @@ anaLogger.assert(1 === 2)
 anaLogger.assert(()=>true, true)
 anaLogger.assert((a, b)=> a === b, true, 2, 2)
 ```
+
+<br/><br/>
+
+###
+
+When an error is detected and should be seen by your app consumers explicitly (for instance, display a dialogue box
+to them), you can hook your logic.
+
+```javascript
+    anaLogger.setErrorHandlerForUserTarget(function (context/*, ...args*/)
+    {
+        // Detect whether we are in a browser
+        if (context.environnment === anaLogger.ENVIRONMENT_TYPE.BROWSER)
+        {
+            // When an error is detected in the Browser, the Browser will see this message
+            anaLogger.alert(`Users explicitly see this message`)
+        }
+    })
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "analogger",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Js Logger",
   "main": "dist/index-cjs.min.cjs",
   "module": "dist/index-esm.min.mjs",
@@ -17,6 +17,7 @@
     "bundle:prod:cjs": "rollup --config rollup-cjs.config.js",
     "bundle:prod:esm": "rollup --config rollup-esm.config.js",
     "bundle:prod": "npm run convert-cjs:esm && npm run convert-cjs:browser && npm run bundle:prod:cjs && npm run bundle:prod:esm",
+    "test": "mocha",
     "demo": "npm run bundle:prod && node example/cjs/demo.cjs"
   },
   "author": "Patrice Thimothee",
@@ -26,23 +27,23 @@
     "type": "git",
     "url": "https://github.com/thimpat/analogger.git"
   },
-  "release": {
-    "branches": [
-      "main",
-      {
-        "name": "ci"
-      },
-      "master"
-    ]
-  },
   "devDependencies": {
     "@babel/core": "^7.17.0",
     "@babel/eslint-parser": "^7.17.0",
     "@babel/preset-env": "^7.16.11",
     "@rollup/plugin-commonjs": "^21.0.1",
     "@rollup/plugin-node-resolve": "^13.1.3",
+    "@semantic-release/changelog": "^6.0.1",
+    "@semantic-release/commit-analyzer": "^9.0.2",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^9.0.0",
+    "@semantic-release/release-notes-generator": "^10.0.3",
     "babel-eslint": "^10.1.0",
+    "capture-console": "^1.0.1",
+    "chai": "^4.3.6",
+    "chai-spies": "^1.0.0",
     "eslint": "^8.8.0",
+    "mocha": "^9.2.0",
     "rollup": "^2.67.0",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-uglify": "^6.0.4",

package/test/integration.cjs

@@ -0,0 +1,109 @@
+const chai = require("chai");
+var capcon = require('capture-console');
+const {anaLogger} = require("../src/cjs/ana-logger.cjs");
+const {LOG_CONTEXT, LOG_TARGETS} = require("../example/cjs/contexts-def.cjs");
+const expect = chai.expect;
+
+describe('In the Terminal', function ()
+{
+    const {anaLogger} = require("../src/cjs/ana-logger.cjs");
+
+    const LOG_CONTEXT = {STANDARD: {}, TEST: {color: "#B18904", symbol: "⏰"}, C1: null, C2: null, C3: null, DEFAULT: {}}
+    const LOG_TARGETS = {ALL: "ALL", DEV1: "TOM", DEV2: "TIM", DEV3: "ME", USER: "USER"}
+
+    before(()=>
+    {
+        anaLogger.setContexts(LOG_CONTEXT);
+        anaLogger.setTargets(LOG_TARGETS);
+    })
+
+    beforeEach(()=>
+    {
+        anaLogger.resetLogHistory()
+        anaLogger.keepLogHistory()
+        anaLogger.setOptions({silent: false, hideError: false})
+        anaLogger.removeOverride()
+        anaLogger.removeOverrideError()
+    })
+
+    describe('AnaLogger', function ()
+    {
+        it('should emulate console.log', function ()
+        {
+            const captured = capcon.captureStdio(function ()
+            {
+                anaLogger.log(`Test Log example C1`);
+            })
+
+            expect(captured.stdout).to.contain(`Test Log example C1`)
+        });
+
+        it('should hide console output when the console behaviour is overridden', function ()
+        {
+            const captured = capcon.captureStdio(function ()
+            {
+                console.log(`Log Before override`);
+                anaLogger.setOptions({silent: true})
+                anaLogger.overrideConsole()
+                console.log(`Log After override`);
+            })
+
+            expect(captured.stdout).to.contain(`Log Before override`)
+            expect(captured.stdout).to.not.contain(`Log After override`)
+        });
+
+        it('should hide console output but keep console input in the log history', function ()
+        {
+            const captured1 = capcon.captureStdio(function ()
+            {
+                anaLogger.keepLogHistory();
+                anaLogger.setOptions({silent: true, hideError: false})
+                anaLogger.log(LOG_CONTEXT.C1, `Test Log example something again`);
+            })
+
+            const captured2 = capcon.captureStdio(function ()
+            {
+                console.log(anaLogger.getLogHistory())
+            })
+
+            expect(captured1.stdout).to.not.contain(`Test Log example something again`)
+            expect(captured2.stdout).to.contain(`Test Log example something again`)
+        });
+
+        it('should hide console error when the console behaviour is overridden', function ()
+        {
+            const captured = capcon.captureStdio(function ()
+            {
+                console.log(`Log Before override`);
+                anaLogger.setOptions({hideError: true})
+                anaLogger.overrideConsole()
+
+                console.error(`Error Before override`);
+                anaLogger.overrideError()
+                console.error(`Error After override`);
+
+                console.log(`Log After override`);
+            })
+
+            expect(captured.stdout).to.contain(`Log Before override`)
+            expect(captured.stdout).to.not.contain(`Error After override`)
+        });
+
+        it('should not show unrelated target logs', function ()
+        {
+            const captured = capcon.captureStdio(function ()
+            {
+                anaLogger.setActiveTarget(LOG_TARGETS.DEV3)
+                anaLogger.log({context: LOG_CONTEXT.TEST, target: LOG_TARGETS.DEV3, lid: 100001}, `Test Log example with active target`);
+                anaLogger.log({context: LOG_CONTEXT.TEST, target: LOG_TARGETS.DEV1, lid: 100002}, `Test Log example with DEV1 target`);
+                anaLogger.log(`Test Log example with DEFAULT target`);
+            })
+
+            expect(captured.stdout).to.contain(`Test Log example with active target`)
+            expect(captured.stdout).to.contain(`Test Log example with DEFAULT target`)
+            expect(captured.stdout).to.not.contain(`Test Log example with DEV1 target`)
+        });
+
+
+    });
+});

package/test/unit.cjs

@@ -0,0 +1,105 @@
+const chai = require("chai");
+const expect = chai.expect;
+const spies = require('chai-spies');
+
+chai.use(spies);
+// sut
+const {anaLogger} = require("../src/cjs/ana-logger.cjs");
+const {LOG_CONTEXT} = require("../example/cjs/contexts-def.cjs");
+
+describe('AnaLogger', function ()
+{
+    const LOG_CONTEXT = {STANDARD: {}, TEST: {color: "#B18904", symbol: "⏰"}, C1: null, C2: null, C3: null, DEFAULT: {}}
+    const LOG_TARGETS = {ALL: "ALL", DEV1: "TOM", DEV2: "TIM", DEV3: "ME", USER: "USER"}
+
+    before(() =>
+    {
+        anaLogger.setContexts(LOG_CONTEXT);
+        anaLogger.setTargets(LOG_TARGETS);
+        anaLogger.setActiveTarget(LOG_TARGETS.DEV3)
+    })
+
+    beforeEach(() =>
+    {
+        anaLogger.resetLogHistory()
+        anaLogger.keepLogHistory()
+    })
+
+    describe('#log()', function ()
+    {
+        it('should emulate console.log', function ()
+        {
+            // Arrange
+            anaLogger.setOptions({silent: false, hideError: false})
+
+            // Act
+            anaLogger.log(`Test Log example C1`);
+            const output = anaLogger.getLogHistory()
+
+            // Assert
+            expect(output).to.contain(`Test Log example C1`)
+        });
+    });
+
+    describe('#assert()', function ()
+    {
+        it('should evaluate condition expressions', function ()
+        {
+            const result = anaLogger.assert(1 === 1)
+            expect(result).to.be.true
+        });
+
+        it('should detect failing condition expressions', function ()
+        {
+            const result = anaLogger.assert(1 === 2)
+            expect(result).to.be.false
+        });
+
+        it('should evaluate function expressions', function ()
+        {
+            const result = anaLogger.assert(() => true, true)
+            expect(result).to.be.true
+        });
+
+        it('should evaluate more complex function expressions', function ()
+        {
+            const result = anaLogger.assert((a, b) => a === b, true, 2, 2)
+            expect(result).to.be.true
+        });
+    });
+
+    describe('#alert()', function ()
+    {
+        it('should not fail on alert', function ()
+        {
+            anaLogger.alert(`Hello from alert`, {aaa: 1012})
+            expect(anaLogger.getLogHistory()).to.contain(`Hello from alert`)
+        });
+    });
+
+    describe('#setLogFormat()', function ()
+    {
+        /**
+         * We use a spy here, but things would have been straightforward with a simple "done" + async on the "it"
+         */
+        it('should replace the default formatter function with the given callback when invoking console.log', function ()
+        {
+            // Arrange
+            const methodToCall = {
+                myMethod: () => { }
+            }
+
+            // Spy on methodToCall.myMethod to check it has been called
+            chai.spy.on(methodToCall, 'myMethod');
+
+            anaLogger.setLogFormat(
+                methodToCall.myMethod
+            );
+
+            console.log(LOG_CONTEXT.C1, `Test Log example C4 with new format`);
+            expect(methodToCall.myMethod).to.have.been.called;
+        });
+    });
+
+
+});