Slf4j.js ➔ Slf4j - Code Metrics - Inspection of "Fixing test errors" - ama-team/voxengine-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( 763fa0...b49d63 )

by Fike

created 2017-09-03 15:28 UTC

Slf4j.js ➔ Slf4j B

↳ Parent: lib/logger/Slf4j.js

Complexity

Conditions	3
Paths	4

Size

Total Lines

126

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
c	1
b	0
f	0
nc	4
dl	0
loc	126
rs	8.2857
nop	2

13 Functions

Rating	Name	Size	Complexity
A	Slf4j.js ➔ ... ➔ this.setLevel	4	1
A	Slf4j.js ➔ ... ➔ this.detachAll	5	1
A	Slf4j.js ➔ ... ➔ this.attachAll	1	1
A	Slf4j.js ➔ ... ➔ this.getContext	1	1
A	Slf4j.js ➔ ... ➔ this.detach	1	1
A	Slf4j.js ➔ ... ➔ this.attach	1	1
A	Slf4j.js ➔ ... ➔ this.getName	1	1
A	Slf4j.js ➔ ... ➔ this.getWriter	1	1
A	Slf4j.js ➔ ... ➔ render	10	1
A	Slf4j.js ➔ ... ➔ this.setWriter	4	1
A	Slf4j.js ➔ ... ➔ log	18	4
A	Slf4j.js ➔ ... ➔ Level.explicit.forEach	5	1
A	Slf4j.js ➔ ... ➔ this.getLevel	1	1

How to fix Long Method

/**
 * @module logger/slf4j
 */

var Context = require('./_common').Context
var Renderer = require('./Renderer').Renderer
var Level = require('./Level').Level

/**
 * @class Slf4j
 *
 * @param {string} [name] Logger name.
 * @param {Context} [context] Logger context.
 *
 * @implements IVarArgLogger
 */
function Slf4j (name, context) {
  if (!context) {
    context = DefaultContext
  }
  // backward compatibility for 0.1.x/0.2.x
  if (!(context instanceof Context)) {
    context = new Slf4j.Context(context, arguments[2])
  }
  var mdc = {}
  var self = this

  function render (pattern, substitutions) {
    var chunks = pattern.split('{}')
    return substitutions.reduce(function (carrier, entry) {
      if (chunks.length > 0) {
        return carrier + Renderer.any(entry, false) + chunks.shift()
      } else {
        return carrier + '\r\n' + Renderer.any(entry, true)
      }
    }, chunks.shift())
  }

  function log (level, pattern) {
    level = Level.find(level)
    if (level.weight < context.getLevel(name).weight) {
      return
    }
    var prefix = '[' + level.id.toUpperCase() + ']'
    if (name) {
      prefix += ' ' + name
    }
    var mdcPrefix = Object.keys(mdc).map(function (key) {
      return key + '=' + Renderer.any(mdc[key])
    }).join(', ')
    if (mdcPrefix) {
      prefix += ' [' + mdcPrefix + ']'
    }
    var subs = [].slice.call(arguments, 2)
    context.getWriter(name).write(render(prefix + ': ' + pattern, subs))
  }

  // noinspection JSUnusedGlobalSymbols
  this.log = log

  Level.explicit.forEach(function (level) {
    self[level.id.toLowerCase()] = function () {
      log.apply(null, [level].concat([].slice.call(arguments)))
    }
  })

  this.getName = function () { return name }

  this.setWriter = function (writer) {
    context.setWriter(name, writer)
    return this
  }

  this.getWriter = function () { return context.getWriter(name) }

  this.setLevel = function (level) {
    context.setLevel(name, level)
    return this
  }

  this.getLevel = function () { return context.getLevel(name) }

  /**
   * @deprecated
   */
  this.setThreshold = this.setLevel

  /**
   * @deprecated
   */
  this.getThreshold = this.getLevel

  this.getContext = function () { return context }

  this.attach = function (name, value) { mdc[name] = value }

  this.detach = function (name) { delete mdc[name] }

  this.attachAll = function (values) { mdc = values }

  this.detachAll = function () {
    var b = mdc
    mdc = {}
    return b
  }

  /**
   * @function Slf4j#trace
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#debug
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#notice
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#info
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#warn
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#error
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */
}

/**
 * @class
 * @extends {Context.<Slf4j>}
 */
Slf4j.Context = function () {
  Context.apply(this, arguments)
  var self = this
  /**
   * @param {string} name
   * @param {Level} [threshold]
   * @param {IWritable} [writer]
   * @return {Slf4j}
   */
  this.create = function (name, threshold, writer) {
    if (threshold) {
      self.setLevel(name, threshold)
    }
    if (writer) {
      self.setWriter(name, writer)
    }
    return new Slf4j(name, self)
  }
}
Slf4j.Context.prototype = Object.create(Context.prototype)
Slf4j.Context.constructor = Slf4j.Context

var DefaultContext = new Slf4j.Context()

/**
 * @function Slf4j.create
 * @param {string} name
 * @param {Level} [level]
 * @param {IWritable} [writer]
 * @return {Slf4j}
 */

/**
 * @function Slf4j.getWriter
 * @param {string} name
 * @return {IWritable}
 */

/**
 * @function Slf4j.setWriter
 * @param {string} name
 * @param {IWritable} writer
 * @return {ILoggerContext.<Slf4j>}
 */

/**
 * @function Slf4j.getLevel
 * @param {string} name
 * @return {Level}
 */

/**
 * @function Slf4j.setLevel
 * @param {string} name
 * @param {Level} level
 * @return {ILoggerContext.<Slf4j>}
 */

/**
 * @deprecated
 * @function Slf4j.getThreshold
 * @param {string} name
 * @return {Level}
 */

/**
 * @deprecated
 * @function Slf4j.setThreshold
 * @param {string} name
 * @param {Level} level
 * @return {ILoggerContext.<Slf4j>}
 */
Object.keys(DefaultContext).forEach(function (method) {
  Slf4j[method] = DefaultContext[method].bind(DefaultContext)
})

/**
 * @param {LoggerOptions} [options]
 * @param {String} [name] Default name to use in case options don't include it
 * @param {Context} [context] Default context
 * @param {Level} [level] Default logging level
 * @return {IVarArgLogger}
 */
Slf4j.factory = function (options, name, context, level) {
  options = options || {}
  if (typeof options.log === 'function') {
    // then instance of logger have been passed
    return options
  }
  if (options.instance) {
    return options.instance
  }
  context = options.context || context || Slf4j
  var logger = context.create(options.name || name, level || options.level)
  logger.attachAll(options.mdc || {})
  return logger
}

Slf4j.Level = Level

module.exports = {
  Slf4j: Slf4j,
  /** @deprecated */
  Context: Slf4j.Context,
  /** @deprecated use Slf4j.Level */
  Level: Level
}


1			/**
2			* @module logger/slf4j
3			*/
4
5			var Context = require('./_common').Context
6			var Renderer = require('./Renderer').Renderer
7			var Level = require('./Level').Level
8
9			/**
10			* @class Slf4j
11			*
12			* @param {string} [name] Logger name.
13			* @param {Context} [context] Logger context.
14			*
15			* @implements IVarArgLogger
16			*/
17			function Slf4j (name, context) {
18			if (!context) {
19			context = DefaultContext
20			}
21			// backward compatibility for 0.1.x/0.2.x
22			if (!(context instanceof Context)) {
23			context = new Slf4j.Context(context, arguments[2])
24			}
25			var mdc = {}
26			var self = this
27
28			function render (pattern, substitutions) {
29			var chunks = pattern.split('{}')
30			return substitutions.reduce(function (carrier, entry) {
31			if (chunks.length > 0) {
32			return carrier + Renderer.any(entry, false) + chunks.shift()
33			} else {
34			return carrier + '\r\n' + Renderer.any(entry, true)
35			}
36			}, chunks.shift())
37			}
38
39			function log (level, pattern) {
40			level = Level.find(level)
41			if (level.weight < context.getLevel(name).weight) {
42			return
43			}
44			var prefix = '[' + level.id.toUpperCase() + ']'
45			if (name) {
46			prefix += ' ' + name
47			}
48			var mdcPrefix = Object.keys(mdc).map(function (key) {
49			return key + '=' + Renderer.any(mdc[key])
50			}).join(', ')
51			if (mdcPrefix) {
52			prefix += ' [' + mdcPrefix + ']'
53			}
54			var subs = [].slice.call(arguments, 2)
55			context.getWriter(name).write(render(prefix + ': ' + pattern, subs))
56			}
57
58			// noinspection JSUnusedGlobalSymbols
59			this.log = log
60
61			Level.explicit.forEach(function (level) {
62			self[level.id.toLowerCase()] = function () {
63			log.apply(null, [level].concat([].slice.call(arguments)))
64			}
65			})
66
67			this.getName = function () { return name }
68
69			this.setWriter = function (writer) {
70			context.setWriter(name, writer)
71			return this
72			}
73
74			this.getWriter = function () { return context.getWriter(name) }
75
76			this.setLevel = function (level) {
77			context.setLevel(name, level)
78			return this
79			}
80
81			this.getLevel = function () { return context.getLevel(name) }
82
83			/**
84			* @deprecated
85			*/
86			this.setThreshold = this.setLevel
87
88			/**
89			* @deprecated
90			*/
91			this.getThreshold = this.getLevel
92
93			this.getContext = function () { return context }
94
95			this.attach = function (name, value) { mdc[name] = value }
96
97			this.detach = function (name) { delete mdc[name] }
98
99			this.attachAll = function (values) { mdc = values }
100
101			this.detachAll = function () {
102			var b = mdc
103			mdc = {}
104			return b
105			}
106
107			/**
108			* @function Slf4j#trace
109			* @param {string} pattern Logging pattern with `{}` as a place for substitution
110			* @param {...object} parameters List of pattern parameters
111			*/
112
113			/**
114			* @function Slf4j#debug
115			* @param {string} pattern Logging pattern with `{}` as a place for substitution
116			* @param {...object} parameters List of pattern parameters
117			*/
118
119			/**
120			* @function Slf4j#notice
121			* @param {string} pattern Logging pattern with `{}` as a place for substitution
122			* @param {...object} parameters List of pattern parameters
123			*/
124
125			/**
126			* @function Slf4j#info
127			* @param {string} pattern Logging pattern with `{}` as a place for substitution
128			* @param {...object} parameters List of pattern parameters
129			*/
130
131			/**
132			* @function Slf4j#warn
133			* @param {string} pattern Logging pattern with `{}` as a place for substitution
134			* @param {...object} parameters List of pattern parameters
135			*/
136
137			/**
138			* @function Slf4j#error
139			* @param {string} pattern Logging pattern with `{}` as a place for substitution
140			* @param {...object} parameters List of pattern parameters
141			*/
142			}
143
144			/**
145			* @class
146			* @extends {Context.<Slf4j>}
147			*/
148			Slf4j.Context = function () {
149			Context.apply(this, arguments)
150			var self = this
151			/**
152			* @param {string} name
153			* @param {Level} [threshold]
154			* @param {IWritable} [writer]
155			* @return {Slf4j}
156			*/
157			this.create = function (name, threshold, writer) {
158			if (threshold) {
159			self.setLevel(name, threshold)
160			}
161			if (writer) {
162			self.setWriter(name, writer)
163			}
164			return new Slf4j(name, self)
165			}
166			}
167			Slf4j.Context.prototype = Object.create(Context.prototype)
168			Slf4j.Context.constructor = Slf4j.Context
169
170			var DefaultContext = new Slf4j.Context()
171
172			/**
173			* @function Slf4j.create
174			* @param {string} name
175			* @param {Level} [level]
176			* @param {IWritable} [writer]
177			* @return {Slf4j}
178			*/
179
180			/**
181			* @function Slf4j.getWriter
182			* @param {string} name
183			* @return {IWritable}
184			*/
185
186			/**
187			* @function Slf4j.setWriter
188			* @param {string} name
189			* @param {IWritable} writer
190			* @return {ILoggerContext.<Slf4j>}
191			*/
192
193			/**
194			* @function Slf4j.getLevel
195			* @param {string} name
196			* @return {Level}
197			*/
198
199			/**
200			* @function Slf4j.setLevel
201			* @param {string} name
202			* @param {Level} level
203			* @return {ILoggerContext.<Slf4j>}
204			*/
205
206			/**
207			* @deprecated
208			* @function Slf4j.getThreshold
209			* @param {string} name
210			* @return {Level}
211			*/
212
213			/**
214			* @deprecated
215			* @function Slf4j.setThreshold
216			* @param {string} name
217			* @param {Level} level
218			* @return {ILoggerContext.<Slf4j>}
219			*/
220			Object.keys(DefaultContext).forEach(function (method) {
221			Slf4j[method] = DefaultContext[method].bind(DefaultContext)
222			})
223
224			/**
225			* @param {LoggerOptions} [options]
226			* @param {String} [name] Default name to use in case options don't include it
227			* @param {Context} [context] Default context
228			* @param {Level} [level] Default logging level
229			* @return {IVarArgLogger}
230			*/
231			Slf4j.factory = function (options, name, context, level) {
232			options = options \|\| {}
233			if (typeof options.log === 'function') {
234			// then instance of logger have been passed
235			return options
236			}
237			if (options.instance) {
238			return options.instance
239			}
240			context = options.context \|\| context \|\| Slf4j
241			var logger = context.create(options.name \|\| name, level \|\| options.level)
242			logger.attachAll(options.mdc \|\| {})
243			return logger
244			}
245
246			Slf4j.Level = Level
247
248			module.exports = {
249			Slf4j: Slf4j,
250			/** @deprecated */
251			Context: Slf4j.Context,
252			/** @deprecated use Slf4j.Level */
253			Level: Level
254			}
255

ama-team / voxengine-sdk

Push — dev ( 763fa0...b49d63 )

Slf4j.js ➔ Slf4j B

Complexity

Size

Duplication

Importance

13 Functions

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like