Initial commit

Author: justinkames

.gitignore

@@ -0,0 +1,5 @@
+/dist/
+/node_modules/
+.idea
+coverage/
+package-lock.json

.npmignore

@@ -0,0 +1,3 @@
+/src/
+.idea
+coverage

.travis.yml

@@ -0,0 +1,6 @@
+  language: node_js
+  node_js:
+    - "7.7.1"
+  cache:
+    directories:
+      - "node_modules"

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Justin Kames
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,89 @@
+# vuejs-logger
+![](https://travis-ci.org/justinkames/vuejs-logger.svg?branch=master)
+
+> vue-js logger works Vue 2. 
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Demo](#demo)
+- [Install](#install)
+- [Usage](#usage)
+- [Maintainers](#maintainers)
+- [Contribute](#contribute)
+- [License](#license)
+
+
+## Introduction 
+
+vuejs-logger is a logging library that enables logging for Vue applications. It restricts log messages that are higher the specified log level. Features include :
+
+- Colored console messages for $log.warning, $log.error and $log.fatal.
+- Possibility to automatically JSON.stringify() the properties passed to the logger.
+- Possibility to display the log level in the console.
+
+```js
+logLevels :  ['debug', 'info', 'warn', 'error', 'fatal']
+```
+## Demo
+
+@ [https://www.webpackbin.com/bins/-KpB0UbGiG2PeFDmqjwi](https://www.webpackbin.com/bins/-KpB0UbGiG2PeFDmqjwi)
+
+## Install
+
+This project uses [node](http://nodejs.org) and [npm](https://npmjs.com). Go check them out if you don't have them locally installed.
+
+```sh
+$ npm install vuejs-logger --save-exact
+```
+
+## Usage
+
+Below you can find an example of how to use vuejs-logger :
+
+```js
+import VueLogger from 'vuejs-logger'
+
+const options = {
+    logLevel : 'debug',
+    // optional : defaults to false if not specified
+    stringifyArguments : false,
+    // optional : defaults to false if not specified
+    showLogLevel : false
+}
+
+Vue.use(VueLogger, options)
+```
+
+```js
+new Vue({
+    data() {
+        return {
+            a : 'a',
+            b : 'b'
+        }
+    },
+
+    created() {
+        this.$log.debug("test", this.a, 123)
+        this.$log.info("test", this.b)
+        this.$log.warn("test")
+        this.$log.error("test")
+        this.$log.fatal("test")
+    }
+})
+```
+
+## Maintainers
+
+[@justinkames](https://github.com/justinkames).
+
+## Contribute
+
+Feel free to dive in! [Open an issue]() or submit PRs.
+
+vuejs-logger follows the [Contributor Covenant](http://contributor-covenant.org/version/1/3/0/) Code of Conduct.
+
+## License
+
+[MIT](LICENSE) © Justin Kames

package.json

@@ -0,0 +1,35 @@
+{
+  "name": "vuejs-logger",
+  "author": "Justin Kames",
+  "version": "1.0.0",
+  "description": "Vuejs-logger, a provides logging functionality for Vue.js.",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/justinkames/vuejs-logger.git"
+  },
+  "scripts": {
+    "test": "istanbul cover _mocha -- --compilers js:babel-core/register -R spec --debug",
+    "transpile": "node_modules/babel-cli/bin/babel.js src --out-dir dist && node_modules/uglify-js/bin/uglifyjs dist/logger.js -c -m -o dist/logger.js",
+    "prepublish": "npm test && npm run transpile"
+  },
+  "license": "MIT",
+  "babel": {
+    "presets": [
+      "es2015"
+    ]
+  },
+  "devDependencies": {
+    "babel-cli": "6.24.1",
+    "babel-core": "6.25.0",
+    "babel-loader": "7.1.1",
+    "babel-preset-es2015": "6.24.1"
+  },
+  "dependencies": {
+    "chai": "4.1.0",
+    "istanbul": "0.4.5",
+    "mocha": "3.4.2",
+    "uglify": "0.1.5",
+    "vuejs-logger": "0.1.11"
+  }
+}

src/index.js

@@ -0,0 +1,6 @@
+import Logger from './logger'
+const o = {
+    install: Logger().install
+}
+window.VueLogger = o
+export default o

src/logger.js

@@ -0,0 +1,57 @@
+export default function () {
+
+    const logLevels = ['debug', 'info', 'warn', 'error', 'fatal']
+
+    function initLoggerInstance (options, logLevels) {
+        const logger = {}
+        logLevels.forEach(logLevel => {
+            if (logLevels.indexOf(logLevel) >= logLevels.indexOf(options.logLevel)) {
+                logger[logLevel] = (...args) => {
+                    const prefix = options.showLogLevel ? logLevel + ' | ' : ''
+                    const formattedArguments = options.stringifyArguments ? args.map(a => JSON.stringify(a)) : args
+                    print(logLevel, prefix, formattedArguments)
+                }
+            } else {
+                logger[logLevel] = () => {}
+            }
+        })
+        return logger
+    }
+
+    function print (logLevel, prefix, formattedArguments) {
+        if (logLevel === 'warn' || logLevel === 'error' || logLevel === 'fatal') {
+            console[logLevel === 'fatal' ? 'error' : logLevel](prefix, ...formattedArguments)
+        } else {
+            console.log(prefix, ...formattedArguments)
+        }
+    }
+
+    function validateOptions (options, logLevels) {
+        if (!(options.logLevel && typeof options.logLevel === 'string' && logLevels.indexOf(options.logLevel) > -1)) {
+            return false
+        }
+        if (options.stringifyArguments && typeof options.stringifyArguments !== 'boolean') {
+            return false
+        }
+        if (options.showLogLevel && typeof options.showLogLevel !== 'boolean') {
+            return false
+        }
+        return true
+    }
+
+    function install (Vue, options) {
+        if (validateOptions(options, logLevels)) {
+            Vue.prototype.$log = initLoggerInstance(options, logLevels)
+        } else {
+            throw new Error('Provided options for vuejs-logger are not valid.')
+        }
+    }
+
+    return {
+        install,
+        validateOptions,
+        print,
+        initLoggerInstance,
+        logLevels
+    }
+}

test/logger.js

@@ -0,0 +1,131 @@
+import chai from 'chai'
+const expect = chai.expect
+import VueLogger from '../src/logger'
+const {print, validateOptions, initLoggerInstance, logLevels, install} = VueLogger()
+
+describe('Logger.js', () => {
+
+    describe('initLoggerInstance()', () => {
+
+        it('initLoggerInstance() should ignore logLevels that are more restrictive than set logLevel.', () => {
+            // with options enabled
+            const a = initLoggerInstance({logLevel: 'info', showLogLevel: true, stringifyArguments: true}, logLevels)
+            a.debug('test')
+            a.info('test', ['test args'], ['test args'])
+            a.warn('test', ['test args'])
+            a.error('test', 'test args')
+            a.fatal('test', ['test args'], 'test args', 'test args')
+
+            // with options disabled
+            const b = initLoggerInstance({logLevel: 'info', showLogLevel: false, stringifyArguments: false}, logLevels)
+            b.debug('test')
+            b.info('test', ['test args'], ['test args'])
+            b.warn('test', ['test args'])
+            b.error('test', 'test args')
+            b.fatal('test', ['test args'], 'test args', 'test args')
+        })
+    })
+
+    describe('validateOptions()', () => {
+
+        it('validateOptions() should pass with correct options.', () => {
+            expect(validateOptions({
+                logLevel: 'debug',
+                stringifyByDefault: false,
+                showLogLevel: false,
+            }, logLevels)).to.equal(true)
+        })
+
+        it('validateOptions() should fail with incorrect options.', () => {
+            expect(validateOptions({
+                logLevel: 'debug',
+                stringifyArguments: 'TEST',
+                showLogLevel: false,
+            }, logLevels)).to.equal(false)
+
+            expect(validateOptions({
+                logLevel: 'debug',
+                stringifyArguments: false,
+                showLogLevel: 'TEST',
+            }, logLevels)).to.equal(false)
+
+            expect(validateOptions({
+                logLevel: 'TEST',
+                stringifyArguments: false,
+                showLogLevel: false,
+            }, logLevels)).to.equal(false)
+        })
+    })
+
+    describe('print()', () => {
+
+        it('print() should use console.error() with fatal logLevel', () => {
+            print('fatal', 'fatal |', ['test'])
+        })
+
+        it('print() should use console.error() with error logLevel', () => {
+            print('error', 'error |', ['test'])
+        })
+
+        it('print() should use console.log() with any other logLevel', () => {
+            print('debug', 'debug |', ['test'])
+        })
+    })
+
+    describe('install()', () => {
+
+        it('install() should work with the correct params.', () => {
+            const Vue = () => {}
+            const options = {
+                logLevel: 'debug',
+                stringifyByDefault: false,
+                showLogLevel: false,
+            }
+            install(Vue, options)
+            Vue()
+
+            expect(Vue.prototype.$log).to.be.a('object')
+            expect(Vue.prototype.$log.debug).to.be.a('function')
+            expect(Vue.prototype.$log.info).to.be.a('function')
+            expect(Vue.prototype.$log.warn).to.be.a('function')
+            expect(Vue.prototype.$log.error).to.be.a('function')
+            expect(Vue.prototype.$log.fatal).to.be.a('function')
+        })
+
+        it('install() should throw an error with the an incorrect log level.', () => {
+            const options = {
+                logLevel: 'foo'
+            }
+            expect(() => { install(() => {}, options) })
+              .to
+              .throw(Error, 'Provided options for vuejs-logger are not valid.')
+        })
+
+        it('install() should throw an error with the an incorrect log level.', () => {
+            const options = {
+                logLevel: false
+            }
+            expect(() => { install(() => {}, options) })
+              .to
+              .throw(Error, 'Provided options for vuejs-logger are not valid.')
+        })
+
+        it('install() should throw an error with the an incorrect log level.', () => {
+            const options = {
+                logLevel: undefined
+            }
+            expect(() => { install(() => {}, options) })
+              .to
+              .throw(Error, 'Provided options for vuejs-logger are not valid.')
+        })
+
+        it('install() should throw an error with the an incorrect log level.', () => {
+            const options = {
+                logLevel: null
+            }
+            expect(() => { install(() => {}, options) })
+              .to
+              .throw(Error, 'Provided options for vuejs-logger are not valid.')
+        })
+    })
+})