lggr - npm Package Compare versions

Comparing version 1.0.0 to 2.0.0

lib/index.js

@@ -11,2 +11,4 @@ /**
 
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
@@ -18,37 +20,65 @@
 
-var _replacer = require('./replacer');
+var _utilsReplacer = require('./utils/replacer');
 
-var _replacer2 = _interopRequireDefault(_replacer);
+var _utilsReplacer2 = _interopRequireDefault(_utilsReplacer);
 
-var _consoleWriter = require('./console/writer');
+var _writersConsole = require('./writers/console');
 
-var _consoleWriter2 = _interopRequireDefault(_consoleWriter);
+var _writersConsole2 = _interopRequireDefault(_writersConsole);
 
-var _consoleFormatter = require('./console/formatter');
+var _writersWebFile = require('./writers/web-file');
 
-var _consoleFormatter2 = _interopRequireDefault(_consoleFormatter);
+var _writersWebFile2 = _interopRequireDefault(_writersWebFile);
 
-var _consoleNormalizer = require('./console/normalizer');
+var _formattersDate = require('./formatters/date');
 
-var _consoleNormalizer2 = _interopRequireDefault(_consoleNormalizer);
+var _formattersDate2 = _interopRequireDefault(_formattersDate);
 
-var _webFileFormatter = require('./web-file/formatter');
+var _formattersMethod = require('./formatters/method');
 
-var _webFileFormatter2 = _interopRequireDefault(_webFileFormatter);
+var _formattersMethod2 = _interopRequireDefault(_formattersMethod);
 
-var _webFileWriter = require('./web-file/writer');
+var _formattersPrefix = require('./formatters/prefix');
 
-var _webFileWriter2 = _interopRequireDefault(_webFileWriter);
+var _formattersPrefix2 = _interopRequireDefault(_formattersPrefix);
 
-var _webFileFile = require('./web-file/file');
+var _formattersPlaceholders = require('./formatters/placeholders');
 
-var _webFileFile2 = _interopRequireDefault(_webFileFile);
+var _formattersPlaceholders2 = _interopRequireDefault(_formattersPlaceholders);
 
+var _formattersPlaceholdersNormalizer = require('./formatters/placeholders-normalizer');
+
+var _formattersPlaceholdersNormalizer2 = _interopRequireDefault(_formattersPlaceholdersNormalizer);
+
+var _formattersJoin = require('./formatters/join');
+
+var _formattersJoin2 = _interopRequireDefault(_formattersJoin);
+
+var _formattersJoinFirst = require('./formatters/join-first');
+
+var _formattersJoinFirst2 = _interopRequireDefault(_formattersJoinFirst);
+
+var _utilsWebFile = require('./utils/web-file');
+
+var _utilsWebFile2 = _interopRequireDefault(_utilsWebFile);
+
+var _utils = require('./utils');
+
+var utils = _interopRequireWildcard(_utils);
+
+var combineFormatters = utils.combineFormatters;
+
 exports.Logger = _logger2['default'];
-exports.Replacer = _replacer2['default'];
-exports.ConsoleWriter = _consoleWriter2['default'];
-exports.ConsoleFormatter = _consoleFormatter2['default'];
-exports.ConsoleNormalizer = _consoleNormalizer2['default'];
-exports.WebFileWriter = _webFileWriter2['default'];
-exports.WebFileFormatter = _webFileFormatter2['default'];
-exports.WebFile = _webFileFile2['default'];
+exports.Replacer = _utilsReplacer2['default'];
+exports.WebFile = _utilsWebFile2['default'];
+exports.createConsoleWriter = _writersConsole2['default'];
+exports.createWebFileWriter = _writersWebFile2['default'];
+exports.createDateFormatter = _formattersDate2['default'];
+exports.createMethodFormatter = _formattersMethod2['default'];
+exports.createPrefixFormatter = _formattersPrefix2['default'];
+exports.createPlaceholdersFormatter = _formattersPlaceholders2['default'];
+exports.createNormalFormatter = _formattersPlaceholdersNormalizer2['default'];
+exports.createJoinFormatter = _formattersJoin2['default'];
+exports.createJoinFirstFormatter = _formattersJoinFirst2['default'];
+exports.combineFormatters = combineFormatters;
+exports.utils = utils;

lib/logger.js

@@ -90,6 +90,5 @@ /**
 
-            this._forEachWriter(function (name, writer, formatter, levels) {
+            this._forEachWriter(function (name, write, format, levels) {
                 if (isMethodAllowed(method, levels)) {
-                    var formattedArgs = formatter ? formatter.format(method, _this._prefix, args) : args;
-                    writer.write(method, _this._prefix, formattedArgs);
+                    write(method, _this._prefix, format ? format(method, _this._prefix, args) : args);
                 }
@@ -96,0 +95,0 @@ });

package.json

 {
   "name": "lggr",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "repository": {
@@ -5,0 +5,0 @@ "type": "git",

README.md

@@ -1,15 +0,34 @@
-# How It Works
-
+## Example
 ```javascript
-import {Logger, ConsoleWriter, ConsoleFormatter, WebFileWriter, WebFileFormatter} from 'logger';
+import * as lggr from 'lggr';
 
+var webFile = new lggr.WebFile({
+    fileName: 'debug.log',
+    oldFileName: 'debug-old.log',
+    maxSize: 5 * 1024 * 1024
+});
+
+var webFileFormatter = lggr.combineFormatters([
+    lggr.createPlaceholdersFormatter(),
+    lggr.createPrefixFormatter(prefix => `-[${prefix}]-`),
+    lggr.createMethodFormatter(method => method.toUpperCase()),
+    lggr.createDateFormatter(),
+    lggr.createJoinFormatter(' # ')
+]);
+
+var consoleFormatter = lggr.combineFormatters([
+    lggr.createNormalFormatter({j: 'o', l: 's'}),
+    lggr.createPrefixFormatter(),
+    lggr.createJoinFirstFormatter(2, '|')
+]);
+
 var options = {
     methods: ['log', 'info', 'warn', 'error'],
     writers: {
-        console: new ConsoleWriter(),
-        file: new WebFileWriter()
+        console: lggr.createConsoleWriter(),
+        file: lggr.createWebFileWriter(webFile)
     },
     formatters: {
-        console: new ConsoleFormatter(),
-        file: new WebFileFormatter()
+        console: consoleFormatter,
+        file: webFileFormatter
     },
@@ -22,3 +41,3 @@ levels: {
 
-var logger = new Logger('log-prefix', options);
+var logger = new lggr.Logger('log-prefix', options);
 
@@ -36,7 +55,7 @@ logger.log('Hello, %s! I am %i years old!', 'world', 142);
 logger.setLevels('console', ['log'])
-logger.addFormatter('file', new ConsoleFormatter())
+logger.addFormatter('file', lggr.createDateFormatter())
 
 // this methods are applied only to otherLogger
 otherLogger.setLevels('console', ['error', 'warn'])
-otherLogger.addFormatter('file', new SomeOtherFormatter())
+otherLogger.addFormatter('file', someOtherFormatterMethod)
 
@@ -43,0 +62,0 @@ var forkedLogger = logger.fork('forked-prefix');

src/index.js

@@ -6,19 +6,38 @@ /**
 import Logger from './logger';
-import Replacer from './replacer';
-import ConsoleWriter from './console/writer';
-import ConsoleFormatter from './console/formatter';
-import ConsoleNormalizer from './console/normalizer';
-import WebFileFormatter from './web-file/formatter';
-import WebFileWriter from './web-file/writer';
-import WebFile from './web-file/file';
+import Replacer from './utils/replacer';
 
+import createConsoleWriter from './writers/console';
+import createWebFileWriter from './writers/web-file';
+
+import createDateFormatter from './formatters/date';
+import createMethodFormatter from './formatters/method';
+import createPrefixFormatter from './formatters/prefix';
+import createPlaceholdersFormatter from './formatters/placeholders';
+import createNormalFormatter from './formatters/placeholders-normalizer';
+import createJoinFormatter from './formatters/join';
+import createJoinFirstFormatter from './formatters/join-first';
+
+import WebFile from './utils/web-file';
+import * as utils from './utils';
+
+var combineFormatters = utils.combineFormatters;
+
 export {
     Logger,
     Replacer,
-    ConsoleWriter,
-    ConsoleFormatter,
-    ConsoleNormalizer,
-    WebFileWriter,
-    WebFileFormatter,
-    WebFile
+    WebFile,
+
+    createConsoleWriter,
+    createWebFileWriter,
+
+    createDateFormatter,
+    createMethodFormatter,
+    createPrefixFormatter,
+    createPlaceholdersFormatter,
+    createNormalFormatter,
+    createJoinFormatter,
+    createJoinFirstFormatter,
+
+    combineFormatters,
+    utils
 };

src/logger.js

@@ -58,8 +58,9 @@ /**
     message (method, ...args) {
-        this._forEachWriter((name, writer, formatter, levels) => {
+        this._forEachWriter((name, write, format, levels) => {
             if (isMethodAllowed(method, levels)) {
-                var formattedArgs = formatter
-                        ? formatter.format(method, this._prefix, args)
-                        : args;
-                writer.write(method, this._prefix, formattedArgs);
+                write(
+                    method,
+                    this._prefix,
+                    format ? format(method, this._prefix, args) : args
+                );
             }
@@ -66,0 +67,0 @@ });

test/logger.spec.js

 
 import Logger from '../src/logger';
-import ConsoleWriter from '../src/console/writer';
-import ConsoleFormatter from '../src/console/formatter';
+import {combineFormatters} from '../src/utils';
+import createPlaceholdersFormatter from '../src/formatters/placeholders';
+import createPrefixFormatter from '../src/formatters/prefix';
+import createMethodFormatter from '../src/formatters/method';
+import createJoinFormatter from '../src/formatters/join';
 
@@ -9,2 +12,17 @@ var sandbox = sinon.sandbox.create();
 describe('Logger', function () {
+    beforeEach(function () {
+        this.format1 = combineFormatters([
+            createPlaceholdersFormatter(),
+            createPrefixFormatter(prefix => prefix ? `${prefix}:` : ''),
+            createMethodFormatter(method => method.toUpperCase()),
+            createJoinFormatter()
+        ]);
+        this.format2 = combineFormatters([
+            createJoinFormatter(' - ')
+        ]);
+
+        this.write1 = sandbox.spy();
+        this.write2 = sandbox.spy();
+    });
+
     afterEach(function () {
@@ -38,81 +56,71 @@ sandbox.restore();
         it('should write to passed writer', function () {
-            var writer = new ConsoleWriter();
-            var formatter = new ConsoleFormatter();
             var logger = new Logger('prefix', {
                 methods: ['log'],
-                writers: {console: writer},
-                formatters: {console: formatter},
+                writers: {console: this.write1},
+                formatters: {console: this.format1},
                 levels: {console: ['log']}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
-            var formatSpy = sandbox.spy(formatter, 'format');
             logger.log('Hello, %s!', 'world');
-            assert.calledOnce(formatSpy);
-            assert.calledOnce(writeSpy);
-            assert.calledWith(formatSpy, 'log', 'prefix', ['Hello, %s!', 'world']);
-            assert.calledWith(writeSpy, 'log', 'prefix', ['prefix: Hello, world!']);
+            assert.calledOnce(this.write1);
+            assert.calledWith(this.write1, 'log', 'prefix', ['LOG prefix: Hello, world!']);
         });
 
+        it('should write to passed writer without prefix', function () {
+            var logger = new Logger(null, {
+                methods: ['log'],
+                writers: {console: this.write1},
+                formatters: {console: this.format1},
+                levels: {console: ['log']}
+            });
+            logger.log('Hello, %s!', 'world');
+            assert.calledOnce(this.write1);
+            assert.calledWith(this.write1, 'log', null, ['LOG  Hello, world!']);
+        });
+
         it('should write to passed writer without formatter', function () {
-            var writer = new ConsoleWriter();
             var logger = new Logger(null, {
                 methods: ['log'],
-                writers: {console: writer},
+                writers: {console: this.write1},
                 formatters: {},
                 levels: {console: ['log']}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
             logger.log('Hello, %s!', 'world');
-            assert.calledOnce(writeSpy);
-            assert.calledWith(writeSpy, 'log', null, ['Hello, %s!', 'world']);
+            assert.calledOnce(this.write1);
+            assert.calledWith(this.write1, 'log', null, ['Hello, %s!', 'world']);
         });
 
         it('should write to passed writer without levels', function () {
-            var writer = new ConsoleWriter();
-            var formatter = new ConsoleFormatter();
             var logger = new Logger('prefix', {
                 methods: ['log'],
-                writers: {console: writer},
-                formatters: {console: formatter},
+                writers: {console: this.write1},
+                formatters: {console: this.format1},
                 levels: {}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
-            var formatSpy = sandbox.spy(formatter, 'format');
             logger.log('Hello, %s!', 'world');
-            assert.calledOnce(formatSpy);
-            assert.calledOnce(writeSpy);
-            assert.calledWith(formatSpy, 'log', 'prefix', ['Hello, %s!', 'world']);
-            assert.calledWith(writeSpy, 'log', 'prefix', ['prefix: Hello, world!']);
+            assert.calledOnce(this.write1);
+            assert.calledWith(this.write1, 'log', 'prefix', ['LOG prefix: Hello, world!']);
         });
 
         it('should write to several passed writers with appropriate levels', function () {
-            var writer = new ConsoleWriter();
-            var writer2 = new ConsoleWriter();
-            var formatter = new ConsoleFormatter();
             var logger = new Logger('prefix', {
                 methods: ['log', 'error'],
-                writers: {console: writer, file: writer2},
-                formatters: {console: formatter, file: formatter},
+                writers: {console: this.write1, file: this.write2},
+                formatters: {console: this.format1, file: this.format2},
                 levels: {console: ['error'], file: ['log', 'error']}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
-            var writeSpy2 = sandbox.spy(writer2, 'write');
-            var formatSpy = sandbox.spy(formatter, 'format');
 
             logger.error('Hello, %s!', 'world');
-            assert.calledOnce(writeSpy);
-            assert.calledOnce(writeSpy2);
-            assert.calledTwice(formatSpy);
-            assert.calledWith(formatSpy, 'error', 'prefix', ['Hello, %s!', 'world']);
-            assert.calledWith(writeSpy, 'error', 'prefix', ['prefix: Hello, world!']);
-            assert.calledWith(writeSpy2, 'error', 'prefix', ['prefix: Hello, world!']);
+            assert.calledOnce(this.write1);
+            assert.calledOnce(this.write2);
+            assert.calledWith(this.write1, 'error', 'prefix', ['ERROR prefix: Hello, world!']);
+            assert.calledWith(this.write2, 'error', 'prefix', ['Hello, %s! - world']);
             sandbox.reset();
 
-            logger.log('Hello %s, %s%i!', 'again', 'world', 111);
-            assert.notCalled(writeSpy);
-            assert.calledOnce(writeSpy2);
-            assert.calledOnce(formatSpy);
-            assert.calledWith(formatSpy, 'log', 'prefix',
-                              ['Hello %s, %s%i!', 'again', 'world', 111]);
-            assert.calledWith(writeSpy2, 'log', 'prefix', ['prefix: Hello again, world111!']);
+            logger.log('Hello', 'again', 'world', 111);
+            assert.notCalled(this.write1);
+            assert.calledOnce(this.write2);
+            assert.calledWith(
+                this.write2, 'log', 'prefix',
+                ['Hello - again - world - 111']
+            );
         });
@@ -124,22 +132,20 @@
         it('should set levels to writer', function () {
-            var writer = new ConsoleWriter();
-            var formatter = new ConsoleFormatter();
             var logger = new Logger('prefix', {
-                methods: ['log', 'info'],
-                writers: {console: writer},
-                formatters: {console: formatter},
+                methods: ['log', 'info', 'error'],
+                writers: {console: this.write1},
+                formatters: {console: this.format1},
                 levels: {console: ['error']}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
-            var formatSpy = sandbox.spy(formatter, 'format');
+
             logger.log('Hello, %s!', 'world');
-            assert.notCalled(formatSpy);
-            assert.notCalled(writeSpy);
+            logger.info('Hello, %s!', 'world');
+            assert.notCalled(this.write1);
 
-            logger.setLevels('console', ['log']);
+            logger.setLevels('console', ['log', 'info']);
             logger.log('Hello, %s!', 'world');
-            assert.calledOnce(formatSpy);
-            assert.calledOnce(writeSpy);
-            assert.calledWith(formatSpy, 'log', 'prefix', ['Hello, %s!', 'world']);
-            assert.calledWith(writeSpy, 'log', 'prefix', ['prefix: Hello, world!']);
+            logger.info('Hello, %s!', 'world');
+            logger.error('Hello, %s!', 'world');
+            assert.calledTwice(this.write1);
+            assert.calledWith(this.write1, 'log', 'prefix', ['LOG prefix: Hello, world!']);
+            assert.calledWith(this.write1, 'info', 'prefix', ['INFO prefix: Hello, world!']);
         });
@@ -150,58 +156,38 @@ });
         it('should add writer and formatter to logger', function () {
-            var writer = new ConsoleWriter();
-            var formatter = new ConsoleFormatter();
-            var writer2 = new ConsoleWriter();
             var logger = new Logger('prefix', {
                 methods: ['log', 'info'],
-                writers: {console: writer},
-                formatters: {console: formatter},
+                writers: {console: this.write1},
+                formatters: {console: this.format1},
                 levels: {console: ['log']}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
-            var writeSpy2 = sandbox.spy(writer2, 'write');
-            var formatSpy = sandbox.spy(formatter, 'format');
 
-            logger.addWriter('file', writer2);
+            logger.addWriter('file', this.write2);
             logger.log('Hello, %s!', 'world');
-
-            assert.calledOnce(writeSpy);
-            assert.calledOnce(writeSpy2);
-            assert.calledOnce(formatSpy);
-            assert.calledWith(formatSpy, 'log', 'prefix', ['Hello, %s!', 'world']);
-            assert.calledWith(writeSpy, 'log', 'prefix', ['prefix: Hello, world!']);
-            assert.calledWith(writeSpy2, 'log', 'prefix', ['Hello, %s!', 'world']);
+            assert.calledOnce(this.write1);
+            assert.calledOnce(this.write2);
+            assert.calledWith(this.write1, 'log', 'prefix', ['LOG prefix: Hello, world!']);
+            assert.calledWith(this.write2, 'log', 'prefix', ['Hello, %s!', 'world']);
             sandbox.reset();
 
-            logger.addFormatter('file', formatter);
+            logger.addFormatter('file', this.format2);
             logger.log('Hello, %s!', 'world');
-
-            assert.calledOnce(writeSpy);
-            assert.calledOnce(writeSpy2);
-            assert.calledTwice(formatSpy);
-            assert.calledWith(formatSpy, 'log', 'prefix', ['Hello, %s!', 'world']);
-            assert.calledWith(writeSpy, 'log', 'prefix', ['prefix: Hello, world!']);
-            assert.calledWith(writeSpy2, 'log', 'prefix', ['prefix: Hello, world!']);
+            assert.calledOnce(this.write1);
+            assert.calledOnce(this.write2);
+            assert.calledWith(this.write1, 'log', 'prefix', ['LOG prefix: Hello, world!']);
+            assert.calledWith(this.write2, 'log', 'prefix', ['Hello, %s! - world']);
         });
 
         it('should remove writer and formatter from logger', function () {
-            var writer = new ConsoleWriter();
-            var formatter = new ConsoleFormatter();
-            var writer2 = new ConsoleWriter();
             var logger = new Logger('prefix', {
                 methods: ['log', 'info'],
-                writers: {console: writer, file: writer2},
-                formatters: {console: formatter, file: formatter},
+                writers: {console: this.write1, file: this.write2},
+                formatters: {console: this.format1, file: this.format2},
                 levels: {console: ['log']}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
-            var writeSpy2 = sandbox.spy(writer2, 'write');
-            var formatSpy = sandbox.spy(formatter, 'format');
 
             logger.log('Hello, %s!', 'world');
-            assert.calledOnce(writeSpy);
-            assert.calledOnce(writeSpy2);
-            assert.calledTwice(formatSpy);
-            assert.calledWith(formatSpy, 'log', 'prefix', ['Hello, %s!', 'world']);
-            assert.calledWith(writeSpy, 'log', 'prefix', ['prefix: Hello, world!']);
-            assert.calledWith(writeSpy2, 'log', 'prefix', ['prefix: Hello, world!']);
+            assert.calledOnce(this.write1);
+            assert.calledOnce(this.write2);
+            assert.calledWith(this.write1, 'log', 'prefix', ['LOG prefix: Hello, world!']);
+            assert.calledWith(this.write2, 'log', 'prefix', ['Hello, %s! - world']);
             sandbox.reset();
@@ -211,8 +197,6 @@
             logger.log('Hello, %s!', 'world');
-            assert.calledOnce(writeSpy);
-            assert.calledOnce(writeSpy2);
-            assert.calledOnce(formatSpy);
-            assert.calledWith(formatSpy, 'log', 'prefix', ['Hello, %s!', 'world']);
-            assert.calledWith(writeSpy, 'log', 'prefix', ['prefix: Hello, world!']);
-            assert.calledWith(writeSpy2, 'log', 'prefix', ['Hello, %s!', 'world']);
+            assert.calledOnce(this.write1);
+            assert.calledOnce(this.write2);
+            assert.calledWith(this.write1, 'log', 'prefix', ['LOG prefix: Hello, world!']);
+            assert.calledWith(this.write2, 'log', 'prefix', ['Hello, %s!', 'world']);
             sandbox.reset();
@@ -222,6 +206,5 @@
             logger.log('Hello, %s!', 'world');
-            assert.notCalled(writeSpy);
-            assert.notCalled(formatSpy);
-            assert.calledOnce(writeSpy2);
-            assert.calledWith(writeSpy2, 'log', 'prefix', ['Hello, %s!', 'world']);
+            assert.notCalled(this.write1);
+            assert.calledOnce(this.write2);
+            assert.calledWith(this.write2, 'log', 'prefix', ['Hello, %s!', 'world']);
         });
@@ -240,52 +223,42 @@ });
         it('should sync options in direction parent->clone', function () {
-            var writer = new ConsoleWriter();
-            var formatter = new ConsoleFormatter();
             var logger = new Logger('prefix', {
                 methods: ['log'],
-                writers: {console: writer},
+                writers: {console: this.write1},
                 formatters: {},
                 levels: {}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
-            var formatSpy = sandbox.spy(formatter, 'format');
 
-            var clonedLogger = logger.clone('new-prefix');
+            var clonedLogger = logger.clone('p');
             logger.setLevels('console', ['log']);
-            logger.addFormatter('console', formatter);
-
+            logger.addFormatter('console', this.format1);
             clonedLogger.log('Hello, %s!', 'world');
-            assert.calledOnce(formatSpy);
-            assert.calledOnce(writeSpy);
-            assert.calledWith(formatSpy, 'log', 'new-prefix', ['Hello, %s!', 'world']);
-            assert.calledWith(writeSpy, 'log', 'new-prefix', ['new-prefix: Hello, world!']);
+            assert.calledOnce(this.write1);
+            assert.calledWith(this.write1, 'log', 'p', ['LOG p: Hello, world!']);
         });
 
         it('should not sync options in direction clone->parent', function () {
-            var writer = new ConsoleWriter();
-            var writer2 = new ConsoleWriter();
-            var formatter = new ConsoleFormatter();
             var logger = new Logger('parent-prefix', {
-                methods: ['log'],
-                writers: {console: writer},
+                methods: ['log', 'error'],
+                writers: {console: this.write1},
                 formatters: {},
                 levels: {console: ['error']}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
-            var writeSpy2 = sandbox.spy(writer2, 'write');
-            var formatSpy = sandbox.spy(formatter, 'format');
 
             var clonedLogger = logger.clone('clone-prefix');
             clonedLogger.setLevels('console', ['log', 'error']);
-            clonedLogger.addFormatter('console', formatter);
-            clonedLogger.addWriter('file', writer2);
+            clonedLogger.addFormatter('console', this.format1);
+            clonedLogger.addWriter('file', this.write2);
 
             logger.log('Hello, %s!', 'world');
-            assert.notCalled(writeSpy);
-            assert.notCalled(formatSpy);
+            assert.notCalled(this.write1);
+            assert.notCalled(this.write2);
+
             logger.setLevels('console', ['log']);
             logger.log('Hello, %s!', 'world');
-            assert.notCalled(formatSpy);
-            assert.notCalled(writeSpy2);
-            assert.calledOnce(writeSpy);
-            assert.calledWith(writeSpy, 'log', 'parent-prefix', ['Hello, %s!', 'world']);
+            assert.notCalled(this.write2);
+            assert.calledOnce(this.write1);
+            assert.calledWith(
+                this.write1, 'log', 'parent-prefix',
+                ['Hello, %s!', 'world']
+            );
         });
@@ -321,14 +294,8 @@
         it('should not sync options', function () {
-            var writer = new ConsoleWriter();
-            var writer2 = new ConsoleWriter();
-            var formatter = new ConsoleFormatter();
             var logger = new Logger('parent-prefix', {
                 methods: ['log'],
-                writers: {console: writer},
+                writers: {console: this.write1},
                 formatters: {},
                 levels: {console: ['error']}
             });
-            var writeSpy = sandbox.spy(writer, 'write');
-            var writeSpy2 = sandbox.spy(writer2, 'write');
-            var formatSpy = sandbox.spy(formatter, 'format');
 
@@ -338,16 +305,13 @@ var forkedLogger = logger.fork('fork-prefix');
             forkedLogger.setLevels('file', ['error', 'warn']);
-            forkedLogger.addFormatter('console', formatter);
-            forkedLogger.addWriter('file', writer2);
+            forkedLogger.addFormatter('console', this.format1);
+            forkedLogger.addWriter('file', this.write2);
 
             logger.log('Hello, %s!', 'world');
-            assert.notCalled(writeSpy);
-            assert.notCalled(formatSpy);
+            assert.notCalled(this.write1);
 
             logger.setLevels('console', ['log']);
-            logger.addWriter('console', ['log']);
 
             forkedLogger.log('Hello, %s!', 'world');
-            assert.notCalled(formatSpy);
-            assert.notCalled(writeSpy);
-            assert.notCalled(writeSpy2);
+            assert.notCalled(this.write1);
+            assert.notCalled(this.write1);
         });
@@ -354,0 +318,0 @@

test/replacer.spec.js

 
-import Replacer from '../src/replacer';
+import Replacer from '../src/utils/replacer';
 
@@ -4,0 +4,0 @@ describe('replacer', function () {

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

84615

increased by7.4%

Number of package files

48

increased by41.18%

Lines of code

2288

increased by11.12%

Number of lines in readme file

66

increased by40.43%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes