Showing 19 of 29 total issues
Function constructor
has 83 lines of code (exceeds 25 allowed). Consider refactoring. Open
constructor(client, server, cfg) {
this.client = client
this.server = server
this.cfg = cfg
Function end_data
has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring. Open
end_data(cb) {
if (!this.found_hb_sep && this.header_lines.length) {
// Headers not parsed yet - must be a busted email
// Strategy: Find the first line that doesn't look like a header.
// Treat anything before that as headers, anything after as body.
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function add_dot_stuffing_and_ensure_crlf_newlines
has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring. Open
add_dot_stuffing_and_ensure_crlf_newlines(data) {
if (!data.length) return data
if (!Buffer.isBuffer(data)) data = Buffer.from(data)
// Make a new buffer big enough to hold two bytes for every one input
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function add_data
has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring. Open
add_data(line) {
if (typeof line === 'string') {
// This shouldn't ever happen...
line = Buffer.from(line, this.encoding)
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function setupClient
has 59 lines of code (exceeds 25 allowed). Consider refactoring. Open
static setupClient(self) {
if (Object.keys(self.client).length === 0) return
const ip = self.client.remoteAddress
if (!ip) {
self.logdebug('setupClient got no IP address for this connection!')
Function createHMailItem
has 58 lines of code (exceeds 25 allowed). Consider refactoring. Open
exports.createHMailItem = function (outbound_context, options, callback) {
const mail_from = options.mail_from || 'sender@domain'
const delivery_domain = options.delivery_domain || 'domain'
const mail_recipients = options.mail_recipients || [
new Address('recipient@domain'),
Function log_if_level
has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring. Open
logger.log_if_level = function (level, key, plugin) {
return function () {
if (logger.loglevel < logger[key]) return
const levelstr = `[${level}]`
let str = ''
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function playTestSmtpConversation
has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open
exports.playTestSmtpConversation = function (
hmail,
socket,
test,
playbook,
Function _get_plugin_path
has 43 lines of code (exceeds 25 allowed). Consider refactoring. Open
_get_plugin_path(name) {
this.hasPackageJson = false
if (!name) name = this.name
const paths = []
Function add_dot_stuffing_and_ensure_crlf_newlines
has 38 lines of code (exceeds 25 allowed). Consider refactoring. Open
add_dot_stuffing_and_ensure_crlf_newlines(data) {
if (!data.length) return data
if (!Buffer.isBuffer(data)) data = Buffer.from(data)
// Make a new buffer big enough to hold two bytes for every one input
Function write
has 36 lines of code (exceeds 25 allowed). Consider refactoring. Open
socket.write = function (line) {
//console.log('MockSocket.write(' + line.replace(/\n/, '\\n').replace(/\r/, '\\r') + ')');
if (playbook.length == 0) {
test.ok(false, 'missing next playbook entry')
test.done()
Function _get_plugin_path
has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring. Open
_get_plugin_path(name) {
this.hasPackageJson = false
if (!name) name = this.name
const paths = []
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function constructor
has 34 lines of code (exceeds 25 allowed). Consider refactoring. Open
constructor(uuid, cfg) {
this.uuid = uuid || '111111-222222-333-4444444'
this.cfg = cfg
this.mail_from = null
this.rcpt_to = []
Function end_data
has 32 lines of code (exceeds 25 allowed). Consider refactoring. Open
end_data(cb) {
if (!this.found_hb_sep && this.header_lines.length) {
// Headers not parsed yet - must be a busted email
// Strategy: Find the first line that doesn't look like a header.
// Treat anything before that as headers, anything after as body.
Function playTestSmtpConversation
has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring. Open
exports.playTestSmtpConversation = function (
hmail,
socket,
test,
playbook,
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function add_data
has 29 lines of code (exceeds 25 allowed). Consider refactoring. Open
add_data(line) {
if (typeof line === 'string') {
// This shouldn't ever happen...
line = Buffer.from(line, this.encoding)
}
Function set
has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring. Open
set(prop_str, val) {
if (arguments.length === 3) {
prop_str = `${arguments[0]}.${arguments[1]}`
val = arguments[2]
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function playTestSmtpConversation
has 5 arguments (exceeds 4 allowed). Consider refactoring. Open
hmail,
socket,
test,
playbook,
callback,
Function setupClient
has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open
static setupClient(self) {
if (Object.keys(self.client).length === 0) return
const ip = self.client.remoteAddress
if (!ip) {
self.logdebug('setupClient got no IP address for this connection!')
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"