Showing 51 of 96 total issues
File user.js
has 372 lines of code (exceeds 250 allowed). Consider refactoring. Open
var bcrypt = require('bcrypt')
, Item = require('./item')
, _ = require('lodash')
, Promise = require('bluebird')
, crypto = require('crypto')
File collection.js
has 331 lines of code (exceeds 250 allowed). Consider refactoring. Open
var _ = require('lodash')
, makeForm = require('./collection/forms.js')
, Promise = require('bluebird')
, Item = require('./collection/item')
, UserCollection = require('./collection/user')
Function exports
has 89 lines of code (exceeds 25 allowed). Consider refactoring. Open
module.exports = function (app) {
var router = app.router();
router.post('/page', savePage);
router.post('/page/:id', savePage);
File summit.js
has 282 lines of code (exceeds 250 allowed). Consider refactoring. Open
require('sys').puts = console.log;
var databaseProvider = require('./db')
, searchProvider = require('./search')
Function exports
has 69 lines of code (exceeds 25 allowed). Consider refactoring. Open
module.exports = function (db, config) {
var client = new elasticsearch.Client({
host: config.db.search.host + ':' + config.db.search.port,
log: 'trace'
});
Function Summit
has 65 lines of code (exceeds 25 allowed). Consider refactoring. Open
function Summit (userConfig) {
var viewDir = path.join(Summit.maindir(), 'views');
this.config = configure(userConfig);
this.env = this.config.environment;
Function exports
has 65 lines of code (exceeds 25 allowed). Consider refactoring. Open
module.exports = function (app) {
var coll = app.collection({
name: 'ForgotPasswordToken',
fields: {
email: 'email',
Function exports
has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring. Open
module.exports = function (db, config) {
var client = new elasticsearch.Client({
host: config.db.search.host + ':' + config.db.search.port,
log: 'trace'
});
- 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 exports
has 62 lines of code (exceeds 25 allowed). Consider refactoring. Open
module.exports = function (app) {
var router = app.router(false);
router.post('/forgot-password', function (req, respond, views, ForgotPassword) {
return ForgotPassword.withEmail(req.params.email)
Function BogartHandlebarsMiddleware
has 60 lines of code (exceeds 25 allowed). Consider refactoring. Open
function BogartHandlebarsMiddleware(viewPaths, options) {
if (!viewPaths || !viewPaths.length) {
throw new Error('bogart-handlebars missing required parameter `viewsPath`');
}
Function defaultConfig
has 60 lines of code (exceeds 25 allowed). Consider refactoring. Open
module.exports = function defaultConfig (userConfig) {
var userConfig = userConfig || {};
var hostname = process.env.HOSTNAME || 'localhost'
, port = process.env.PORT || 1337
Function search
has 51 lines of code (exceeds 25 allowed). Consider refactoring. Open
return function search (opts) {
var matchField = opts.exact === false ? 'term' : 'match';
var collection = opts.collection;
var query = opts.query;
Function makeMethodRoutes
has 50 lines of code (exceeds 25 allowed). Consider refactoring. Open
function makeMethodRoutes (collection) {
var router = collection.router;
for (var k in collection.methods) {
if (k.indexOf('$GET') === k.length - 4) {
Function _setup
has 47 lines of code (exceeds 25 allowed). Consider refactoring. Open
Summit.prototype._setup = function () {
var self = this;
var defaultViewDir = path.join(__dirname, '..', 'views');
this.viewDirs.push(defaultViewDir);
Function exports
has 47 lines of code (exceeds 25 allowed). Consider refactoring. Open
module.exports = function (app) {
var User = app.collection({
name: 'User',
isUserType: true,
fields: {
Function exports
has 46 lines of code (exceeds 25 allowed). Consider refactoring. Open
module.exports = function (app) {
return app.collection({
name: 'Post',
isPostType: true,
timestamps: true,
Function contains
has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open
GroupCollection.prototype.contains = function (id, opts) {
var keys = _.isArray(id) ? id : [id]
, self = this
, view = (opts && opts.view) ? opts.view : 'contains'; // Allow the user to override the view used
Function errorResponse
has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring. Open
function errorResponse(config, req, err) {
var message = '<h3>Message:</h3>';
if (config.showError) {
if (typeof err === 'string') {
- 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 exports
has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring. Open
module.exports = function (db) {
return function search (opts) {
var opts = _.extend({}, {include_docs: true}, opts || {});
if (!opts.filter && opts.collection) {
- 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 validate
has 43 lines of code (exceeds 25 allowed). Consider refactoring. Open
UserCollection.prototype.validate = function (user) {
var services = ['password', 'facebook', 'twitter']
, identifiers = ['email', 'facebookId', 'twitterId', 'username']
, userIdentifiers = [];