Showing 25 of 598 total issues
File index.js
has 608 lines of code (exceeds 250 allowed). Consider refactoring. Open
Open
'use strict'
const electron = require('electron')
const app = electron.app
const BrowserWindow = electron.BrowserWindow
const ipc = electron.ipcMain
File sync.js
has 362 lines of code (exceeds 250 allowed). Consider refactoring. Open
Open
'use strict'
/**
* sync.js
* Main cloud sync functionality
******************************/
Function Setup
has 116 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
function Setup (callback) {
let win = new BrowserWindow({
width: 640,
height: 420,
center: true,
Function Cryptobar
has 90 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
function Cryptobar (callback) {
function click (e, bounds) {
if (e.altKey || e.shiftKey || e.ctrlKey || e.metaKey) {
return hideWindow()
}
Function MasterPassPrompt
has 75 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
exports.MasterPassPrompt = function (reset, callback) {
let tries = 0
let gotMP = false
let error = null
let win = new BrowserWindow({
Function resolveFileType
has 70 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
function resolveFileType (fileType) {
switch (fileType) {
case 'png':
case 'jpg':
case 'jpeg':
Function Cryptobar
has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring. Open
Open
function Cryptobar (callback) {
function click (e, bounds) {
if (e.altKey || e.shiftKey || e.ctrlKey || e.metaKey) {
return hideWindow()
}
- 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 getAllFiles
has 55 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
exports.getAllFiles = function (email) {
// get all drive files and start downloading them
logger.verbose(`PROMISE for retrieving all of ${email} files`)
return new Promise(
function (resolve, reject) {
Function addAccountPrompt
has 54 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
function addAccountPrompt (callback) {
let win = new BrowserWindow({
width: 580,
height: 420,
center: true,
Function init
has 52 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
exports.init = function () {
return new Promise(function (resolve, reject) {
// Set drain (callback) handlers
exports.initDrains()
Function decrypt
has 36 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
exports.decrypt = function (origpath, destpath, key, iv, authTag, callback) {
// encrypts any arbitrary data passed with the pass
// const pass = (Array.isArray(key)) ? shares2pass(key) : key
if (!authTag || !iv) {
// extract from last line of file
Function encrypt
has 34 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
exports.encrypt = function (origpath, destpath, mpkey, callback) {
// decrypts any arbitrary data passed with the pass
let pass = (Array.isArray(mpkey)) ? exports.shares2pass(mpkey) : mpkey
// pass = password
const salt = crypto.randomBytes(defaults.keyLength) // generate pseudorandom salt
Function ErrorPrompt
has 30 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
function ErrorPrompt (err, callback) {
let win = new BrowserWindow({
width: 240,
height: 120,
center: true,
Function Settings
has 29 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
function Settings (callback) {
let win = new BrowserWindow({
width: 800,
height: 600,
center: true
Function decrypt
has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring. Open
Open
exports.decrypt = function (origpath, destpath, key, iv, authTag, callback) {
// encrypts any arbitrary data passed with the pass
// const pass = (Array.isArray(key)) ? shares2pass(key) : key
if (!authTag || !iv) {
// extract from last line of file
- 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 main
has 27 lines of code (exceeds 25 allowed). Consider refactoring. Open
Open
exports.main = function () {
// Decrypt db (the Vault) and get ready for use
// open mdb
logger.verbose(`PROMISE: Main initialisation`)
return new Promise(function (resolve, reject) {
Function decrypt
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
Open
exports.decrypt = function (origpath, destpath, key, iv, authTag, callback) {
Function Account
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
Open
function Account (type, name, email, profileImg, quota, oauth) {
Function decryptObj
has 5 arguments (exceeds 4 allowed). Consider refactoring. Open
Open
exports.decryptObj = function (origpath, mpkey, viv, vtag, callback) {
Function encryptObj
has 5 arguments (exceeds 4 allowed). Consider refactoring. Open
Open
exports.encryptObj = function (obj, destpath, mpkey, viv, callback) {