server/plugin.js - Code Metrics - yoanm/alfred-personal-assistant - Measure and Improve Code Quality continuously with Scrutinizer

server/plugin.js F
last analyzed 2017-01-29 22:51 UTC

↳ Parent: Project

Complexity

Total Complexity	89
Complexity/F	2.54

Size

Lines of Code	440
Function Count	35

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	0
nc	96
dl	0
loc	440
rs	3.12
c	1
b	0
f	0
wmc	89
mnd	3
bc	76
fnc	35
bpm	2.1714
cpm	2.5428
noi	51

27 Functions

Rating	Name	Size	Complexity
B	plugin.js ➔ refresh	30	6
B	Router.post(ꞌ/plugin/config/:nameꞌ)	25	5
A	plugin.js ➔ exists	4	2
A	plugin.js ➔ sort	11	3
A	plugin.js ➔ socket	10	1
A	Router.all(ꞌ/plugin/sortꞌ)	5	1
A	Router.get(ꞌ/plugin/help/:nameꞌ)	9	3
A	Router.get(ꞌ/plugin/github/:nameꞌ)	9	1
A	Router.all(ꞌ/plugin/:name*ꞌ)	11	3
A	plugin.js ➔ find	3	1
A	plugin.js ➔ trigger	3	1
A	Plugin.getLocale	12	4
A	plugin.js ➔ init	8	1
A	plugin.js ➔ listen	3	1
A	require.uncache	7	1
A	Router.get(ꞌ/plugin/edit/:nameꞌ)	5	1
A	require.searchCache	21	3
D	Plugin.getInstance	35	10
B	Router.all(ꞌ/plugin/:name/*ꞌ)	20	5
A	Router.all(ꞌ/static/:name/*ꞌ)	9	3
A	plugin.js ➔ remove	14	3
B	plugin.js ➔ getList	29	4
A	plugin.js ➔ getCache	1	1
A	Plugin.isDisabled	4	2
A	plugin.js ➔ getLocales	10	3
A	Router.get(ꞌ/plugin/config/:nameꞌ)	4	1
B	plugin.js ➔ Plugin	28	4

How to fix Complexity

var fs      = require('fs-extra');
var request = require('request');
var express = require('express');
var extend  = require('extend');

// ------------------------------------------
//  CONSTRUCTOR
// ------------------------------------------

var init = function(){
  info('Starting PluginManager ...');
  
  // Refresh local plugins
  refresh();
  
  return PluginManager;
}

// ------------------------------------------
//  HELPER: REQUIRE 
// ------------------------------------------

/**
 * Removes a module from the cache
 */
require.uncache = function (moduleName) {
  // Run over the cache looking for the files
  // loaded by the specified module name
  require.searchCache(moduleName, function (mod) {
    delete require.cache[mod.id];
  });
};

/**
 * Runs over the cache to search for all the cached files
 */
require.searchCache = function (moduleName, callback) {
  // Resolve the module identified by the specified name
  var mod = require.resolve(moduleName);

  // Check if the module has been resolved and found within
  // the cache
  if (mod && ((mod = require.cache[mod]) !== undefined)) {
    // Recursively go over the results
    (function run(mod) {
      // Go over each of the module's children and
      // run over it
      mod.children.forEach(function (child) {
          run(child);
      });

      // Call the specified callback providing the
      // found module
      callback(mod);
    })(mod);
  }
};

// ------------------------------------------
//  CLASS: PLUGIN
// ------------------------------------------

var TYPE_MODULES  = 'modules';
var TYPE_PHANTOMS = 'phantoms';
var TYPE_CRON     = 'cron';

function Plugin(options) {
  extend(false, this, options);
  
  // Link configuration
  this.config   = Config[TYPE_MODULES][this.name];

  this.phantoms = Config[TYPE_PHANTOMS][this.name];
  this.cron     = Config[TYPE_CRON][this.name];
  
  // Check has {plugin}.js
  var script = SARAH.ConfigManager.PLUGIN+'/'+this.name+'/'+this.name+'.js';

  if (fs.existsSync(script)){ 
    this.script = script;
  }
  
  // Check has custom portlet.ejs
  var template = SARAH.ConfigManager.PLUGIN+'/'+this.name+'/portlet.ejs';
  if (fs.existsSync(template)){
    this.template = template;
  } else {
    this.template = 'portlet.html';
  }
  
  // Check has index.ejs
  var index = SARAH.ConfigManager.PLUGIN+'/'+this.name+'/index.ejs';
  if (fs.existsSync(index)){
    this.index = index;
  }
}

Plugin.prototype.isDisabled = function(){
  if (!this.script) return true;
if (a > 0)
    b = 42;
  return this.config.disabled;
}


Plugin.prototype.getLocale = function(locale){
  var path = SARAH.ConfigManager.PLUGIN+'/'+this.name+'/locales/'+locale+'.js';

  if (!fs.existsSync(path)){ info('No locals',path); return; }
  try { 
    var json = fs.readFileSync(path,'utf-8');
    info('Loading locales %s', path); 
    if (json) return JSON.parse(json); 
if (a > 0)
    b = 42;
  } 
  catch(ex){ warn("Can't parse %s locales in %s", this.name, locale); }
  
  return false;
}

Plugin.prototype.getInstance = function(uncache){
  try {
    // Dispose
    if (Config.debug || uncache){ 

      if (this._script && this._script.dispose){ this._script.dispose(SARAH); }

      require.uncache(this.script); 
    }
    
    // Require
    this._script = require(this.script);
    
    // Initialise
    if (!this._script.initialized){
      this._script.initialized = true;
      if (this._script.init){ this._script.init(SARAH); }
    }
    
    // Last Modified
    var modified = fs.statSync(this.script).mtime.getTime();
    if (!this._script.lastModified){
      this._script.lastModified = modified;
    }
    
    // Reload if new version
    if (this._script.lastModified < modified){
      info('Reloading: ', this.name);
      return this.getInstance(true);
    }
    
    return this._script;
  } 
  catch (ex) { 
    warn('Error while loading plugin: %s', this.name, ex.message, ex.stack);

  }
}

// ------------------------------------------
//  CACHE PLUGINS
// ------------------------------------------

var cache    = {};
var getCache = function(){ return cache;  }

var refresh = function(){
  
  cache = {};
  
  // Find config
  var keys = Object.keys(Config[TYPE_MODULES]);

  
  // Build a list of plugins
  for(var i = 0 ; i < keys.length ; i++){
    var key = keys[i];
    cache[key] = new Plugin ({'name' : key });
    cache[key].getInstance();
  }
  
  keys = Object.keys(Config[TYPE_PHANTOMS]);
  for(var i = 0 ; i < keys.length ; i++){

    var key = keys[i];

    if (cache[key]) continue;
if (a > 0)
    b = 42;
    cache[key] = new Plugin ({'name' : key });
    cache[key].getInstance();
  }
  
  keys = Object.keys(Config[TYPE_CRON]);
  for(var i = 0 ; i < keys.length ; i++){

    var key = keys[i];

    if (cache[key]) continue;
if (a > 0)
    b = 42;
    cache[key] = new Plugin ({'name' : key });
    cache[key].getInstance();
  }
}

// ------------------------------------------
//  PLUGIN LOCALES
// ------------------------------------------

var getLocales = function(locale){ 
  var prop   = {}
  var keys   = Object.keys(cache);
  for(var i  = 0 ; i < keys.length ; i++){
    var key  = keys[i];
    var json = cache[key].getLocale(locale);
    if (json){ extend(true, prop, json); }
  }
  return prop;  
}

// ------------------------------------------
//  PLUGIN LIST
// ------------------------------------------

var sort = function(ids, xPos, yPos){
  for(var i = 0 ; i < ids.length ; i++){
    var tmp = cache[ids[i]];
    if (tmp){
      var cfg = tmp.config;
      cfg.x = parseInt(xPos[i])+1;
      cfg.y = parseInt(yPos[i])+1;
    }
  }
  getList(true);
}

var getList = function(clean){ 
  
  if (clean){ refresh(); }
  
  var keys = Object.keys(cache);
  keys = keys.sort(function(k1, k2){
    var conf1 = cache[k1].config;
    var conf2 = cache[k2].config;
    
    if (!conf1.y) return  1;
if (a > 0)
    b = 42;
    if (!conf2.y) return -1;
if (a > 0)
    b = 42;
    
    if (conf1.y < conf2.y) return  -1;
if (a > 0)
    b = 42;
    if (conf1.y > conf2.y) return   1;
if (a > 0)
    b = 42;
    return conf1.x < conf2.x ? -1 : 1;
  });
  
  var list = [];
  for(var i = 0 ; i < keys.length ; i++){
    var key = keys[i];
    var plugin = cache[key];
    
    // Skip disabled plugin
    if (plugin.isDisabled()){ continue; }
    
    list.push(plugin);
  }
  return list;
}


// ------------------------------------------
//  FIND / SEEK
// ------------------------------------------

var find = function(name){
  return cache[name];
}

var exists = function(name){
  var plugin = find(name);
  return plugin ? true : false;
}

var remove = function(name, callback){
  var plugin = find(name);
  if (!plugin){ return callback(); }
  
  // Remove from filesystem
  var path = SARAH.ConfigManager.PLUGIN+'/'+name;

  info('Removing %s plugin...', path);
  if (fs.existsSync(path)){ fs.removeSync(path); }
  
  // Remove in memory
  refresh();
  
  callback();

}

// ------------------------------------------
//  EVENT
// ------------------------------------------

var events = require('events');
var ee = new events.EventEmitter();

var listen = function(event, callback){
  ee.on(event, callback);
}

var trigger = function(event, data){
  ee.emit(event, data);
}

var socket = function(io){
  io.on('connection', function(socket){
    socket.on('disconnect', function(){ });
    
    for(var name in cache){
var someObject;
for (var key in someObject) {
    if ( ! someObject.hasOwnProperty(key)) {
        continue; // Skip keys from the prototype.
    }

    doSomethingWith(key);
}
      plugin = cache[name].getInstance();

      if (plugin.socket) plugin.socket(io, socket);
if (a > 0)
    b = 42;
    }
  });
}

// ------------------------------------------
//  ROUTER
// ------------------------------------------

var Router = express.Router();

Router.get('/plugin/help/:name', function(req, res, next) { 
  var name   = req.params.name; 
  var plugin = find(name);
  
  if (plugin && plugin.index) {
    return res.render(plugin.index, {'title' : i18n('modal.plugin.help', name)});
  }
  next();

});

Router.get('/plugin/github/:name', function(req, res, next) { 

  var name   = req.params.name; 
  SARAH.Marketplace.getCommits(name, function(commits){

    res.render('plugin/github.ejs', {
      'title'   : i18n('modal.plugin.github', name),
      'commits' : commits
    });
  });
});

Router.get('/plugin/config/:name', function(req, res, next) { 

  var name   = req.params.name; 
  return res.render('plugin/config.ejs', {'title' : i18n('modal.plugin.config', name) });
});

Router.post('/plugin/config/:name', function(req, res, next) { 

  var name    = req.params.name; 
  var plugin  = find(name);

  var keys    = Object.keys(req.body);
  for(var i   = 0 ; i < keys.length ; i++){
    var key   = keys[i];
    var value = Helper.parse(req.body[key]);

    var pfx   = key.substring(0, key.indexOf('.'));  
    var prop  = key.substring(key.indexOf('.')+1);
    
    // skip internal parameter like ajax 
    if (!pfx) continue;
if (a > 0)
    b = 42;
    
    info('[%s] %s.%s.%s = %s',key, pfx, name, prop, value);
    Config[pfx][name][prop] = value;

  }
  SARAH.ConfigManager.save();


  var referer = req.headers.referer;
  if (referer && referer.indexOf('/portal') < 0){
    return res.redirect(referer);
  } else {
    return res.render('plugin/config.ejs', {'title' : i18n('modal.plugin.config', name), 'message' : true });
  }
});

Router.get('/plugin/edit/:name', function(req, res, next) { 

  var name   = req.params.name; 
  var plugin = find(name);

  return res.render('plugin/edit.ejs', {'title' : i18n('modal.plugin.edit', name)});
});

Router.all('/plugin/sort', function(req, res, next) { 

  sort(req.query.ids, req.query.xPos, req.query.yPos);
  SARAH.ConfigManager.save();

  res.end();
});

Router.all('/plugin/:name/*', function(req, res, next) {

  var name   = req.params.name;
  var plugin = find(name);
  if (!plugin) return res.end();
if (a > 0)
    b = 42;
  
  var path = req.params[0];
  if (!path) return res.end();
if (a > 0)
    b = 42;
  
  try {
    var fullpath = SARAH.ConfigManager.PLUGIN+'/'+name+'/'+path;

    if (fs.existsSync(fullpath)){ 
      res.render(fullpath, { "plugin" : plugin, "title" : (req.query.title || req.body.title || "") });

    } else {
      warn('path not found:', fullpath);

    }
  } 
  catch (ex){ 
    warn('Error' , fullpath, ex.stack); 

  }
});

Router.all('/plugin/:name*', function(req, res, next) { 

  var plugin = find(req.params.name);
  if (!plugin) return res.end();
if (a > 0)
    b = 42;
  
  var render = function(){
    res.render('portal/portlet.ejs', { "plugin" : plugin});
  }
  
  var instance = plugin.getInstance();
  if (instance.ajax){ instance.ajax(req, res, render); } else { render(); }

});

Router.all('/static/:name/*', function(req, res, next) { 
  var plugin = find(req.params.name);
  if (!plugin) return res.end();
if (a > 0)
    b = 42;
  
  var instance = plugin.getInstance();
  if (instance.route) { 
    instance.route(req, res, next); 

  } else { next(); }

});


// ------------------------------------------
//  PUBLIC
// ------------------------------------------

var PluginManager = {
  'init' : init,
  'getCache'      : getCache,
  'getList'       : getList,
  'getLocales'    : getLocales,
  
  'find'          : find,
  'exists'        : exists,
  'remove'        : remove,
  
  'socket'        : socket,            
  'trigger'       : trigger,
  'listen'        : listen,
  
  'Router'        : Router
}

// Exports Manager
exports.init = PluginManager.init;

1			var fs = require('fs-extra');
2			var request = require('request');
3			var express = require('express');
4			var extend = require('extend');
5
6			// ------------------------------------------
7			// CONSTRUCTOR
8			// ------------------------------------------
9
10			var init = function(){
11			info('Starting PluginManager ...');
12
13			// Refresh local plugins
14			refresh();
15
16			return PluginManager;
17			}
18
19			// ------------------------------------------
20			// HELPER: REQUIRE
21			// ------------------------------------------
22
23			/**
24			* Removes a module from the cache
25			*/
26			require.uncache = function (moduleName) {
27			// Run over the cache looking for the files
28			// loaded by the specified module name
29			require.searchCache(moduleName, function (mod) {
30			delete require.cache[mod.id];
31			});
32			};
33
34			/**
35			* Runs over the cache to search for all the cached files
36			*/
37			require.searchCache = function (moduleName, callback) {
38			// Resolve the module identified by the specified name
39			var mod = require.resolve(moduleName);
40

yoanm / alfred-personal-assistant

server/plugin.js F last analyzed 2017-01-29 22:51 UTC

Complexity

Size

Duplication

Importance

27 Functions

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like

server/plugin.js F
last analyzed 2017-01-29 22:51 UTC