p71924506
/
cylon
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #237 from hybridgroup/add/repository 

Add Repository class, restructure external module loading
This commit is contained in:
Ron Evans 2014-11-04 09:14:14 -08:00
parent 0cd85988e4 966f8aa530
commit e17dd743c9
14 changed files with 258 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
lib/connection.js
View File

@ -10,9 +10,12 @@
var EventEmitter = require('events').EventEmitter;
var Logger = require('./logger'),
var Registry = require('./registry'),
Logger = require('./logger'),
Utils = require('./utils');
var testMode = process.env.NODE_ENV === 'test' && !CYLON_TEST;
// Public: Creates a new Connection
//
// opts - hash of acceptable params:
@ -87,8 +90,30 @@ Connection.prototype.disconnect = function(callback) {
//
// Returns the set-up adaptor
Connection.prototype.initAdaptor = function(opts) {
Logger.debug("Loading adaptor '" + opts.adaptor + "'.");
return this.robot.initAdaptor(opts.adaptor, this, opts);
var module = Registry.findByAdaptor(opts.adaptor);
opts.connection = this;
if (!module) {
Registry.register('cylon-' + opts.adaptor);
module = Registry.findByAdaptor(opts.adaptor);
}
var adaptor = module.adaptor(opts);
if (testMode) {
var testAdaptor = Registry.findByAdaptor('test').adaptor(opts);
for (var prop in adaptor) {
if (typeof adaptor[prop] === 'function' && !testAdaptor[prop]) {
testAdaptor[prop] = function() { return true; };
}
}
return testAdaptor;
}
return adaptor;
};
Connection.prototype._logstring = function _logstring(action) {

56
lib/device.js
View File

@ -10,9 +10,12 @@
var EventEmitter = require('events').EventEmitter;
var Logger = require('./logger'),
var Registry = require('./registry'),
Logger = require('./logger'),
Utils = require('./utils');
var testMode = process.env.NODE_ENV === 'test' && !CYLON_TEST;
// Public: Creates a new Device
//
// opts - object containing Device params
@ -34,7 +37,7 @@ var Device = module.exports = function Device(opts) {
this.robot = opts.robot;
this.name = opts.name;
this.pin = opts.pin;
this.connection = this.determineConnection(opts.connection) || this.defaultConnection();
this.connection = opts.connection;
this.driver = this.initDriver(opts);
this.details = {};
@ -93,29 +96,6 @@ Device.prototype.toJSON = function() {
};
};
// Public: Retrieves the connections from the parent Robot instances
//
// conn - name of the connection to fetch
//
// Returns a Connection instance
Device.prototype.determineConnection = function(conn) {
return this.robot.connections[conn];
};
// Public: Returns a default Connection to use
//
// Returns a Connection instance
Device.prototype.defaultConnection = function() {
var first = 0;
for (var c in this.robot.connections) {
var connection = this.robot.connections[c];
first = first || connection;
}
return first;
};
// Public: sets up driver with @robot
//
// opts - object containing options when initializing driver
@ -123,10 +103,28 @@ Device.prototype.defaultConnection = function() {
//
// Returns the set-up driver
Device.prototype.initDriver = function(opts) {
if (opts == null) {
opts = {};
var module = Registry.findByDriver(opts.driver);
opts.device = this;
if (!module) {
Registry.register('cylon-' + opts.driver);
module = Registry.findByDriver(opts.driver);
}
Logger.debug("Loading driver '" + opts.driver + "'.");
return this.robot.initDriver(opts.driver, this, opts);
var driver = module.driver(opts);
if (testMode) {
var testDriver = Registry.findByDriver('test').driver(opts);
for (var prop in driver) {
if (typeof driver[prop] === 'function' && !testDriver[prop]) {
testDriver[prop] = function() { return true; };
}
}
return testDriver;
}
return driver;
};

7
lib/driver.js
View File

@ -21,13 +21,14 @@ var Basestar = require('./basestar'),
// Returns a new Driver
var Driver = module.exports = function Driver(opts) {
opts = opts || {};
var extraParams = opts.extraParams || {}
this.name = opts.name;
this.device = opts.device;
this.connection = this.device.connection;
this.connection = opts.connection;
this.adaptor = this.connection.adaptor;
this.interval = extraParams.interval || 10;
this.interval = opts.interval || 10;
this.commands = {};
};

81
lib/registry.js Normal file
View File

@ -0,0 +1,81 @@
/*
* Registry
*
* The Registry contains references to all Drivers and Adaptors Cylon is aware
* of, along with which module they live in (e.g. cylon-firmata).
*
* cylonjs.com
*
* Copyright (c) 2013-2014 The Hybrid Group
* Licensed under the Apache 2.0 license.
*/
"use strict";
var missingModuleError = function(module) {
var string = "Cannot find the '" + module + "' module.\n";
string += "This problem might be fixed by installing it with 'npm install " + module + "' and trying again.";
console.log(string);
process.emit('SIGINT');
};
var Registry = module.exports = {
data: {},
register: function(module) {
if (this.data[module]) {
return;
}
var pkg;
try {
pkg = require(module);
} catch (e) {
if (e.code === "MODULE_NOT_FOUND") {
missingModuleError(module);
}
throw e;
}
this.data[module] = {
module: pkg,
adaptors: pkg.adaptors || [],
drivers: pkg.drivers || []
};
if (pkg.dependencies && Array.isArray(pkg.dependencies)) {
pkg.dependencies.forEach(function(dep) {
Registry.register(dep);
});
}
},
findByAdaptor: function(adaptor) {
return this.search("adaptors", adaptor);
},
findByDriver: function(driver) {
return this.search("drivers", driver);
},
search: function(entry, value) {
for (var name in this.data) {
var repo = this.data[name];
if (~repo[entry].indexOf(value)) {
return repo.module;
}
}
return false;
}
};
// Default drivers/adaptors:
['loopback', 'ping', 'test-adaptor', 'test-driver'].forEach(function(module) {
Registry.register('./test/' + module);
});

189
lib/robot.js
View File

@ -60,10 +60,6 @@ var Robot = module.exports = function Robot(opts) {
var methods = [
"toString",
"registerDriver",
"requireDriver",
"registerAdaptor",
"requireAdaptor",
"halt",
"startDevices",
"startConnections",
@ -89,18 +85,9 @@ var Robot = module.exports = function Robot(opts) {
this.work = function() { Logger.debug("No work yet."); };
}
this.registerDefaults();
this.initConnections(opts.connection || opts.connections);
this.initDevices(opts.device || opts.devices);
var hasDevices = !!Object.keys(this.devices).length,
hasConnections = !!Object.keys(this.connections).length;
if (hasDevices && !hasConnections) {
throw new Error("No connections specified");
}
for (var n in opts) {
var opt = opts[n];
@ -143,17 +130,6 @@ var Robot = module.exports = function Robot(opts) {
Utils.subclass(Robot, EventEmitter);
// Public: Registers the default Drivers and Adaptors with Cylon.
//
// Returns nothing.
Robot.prototype.registerDefaults = function registerDefaults() {
this.registerAdaptor("./test/loopback", "loopback");
this.registerAdaptor("./test/test-adaptor", "test");
this.registerDriver("./test/ping", "ping");
this.registerDriver("./test/test-driver", "test");
};
// Public: Generates a random name for a Robot.
//
// Returns a string name
@ -200,6 +176,8 @@ Robot.prototype.initConnections = function(connections) {
connections = [].concat(connections);
connections.forEach(function(conn) {
conn.robot = this;
if (this.connections[conn.name]) {
var original = conn.name;
conn.name = Utils.makeUnique(original, Object.keys(this.connections));
@ -207,7 +185,7 @@ Robot.prototype.initConnections = function(connections) {
}
Logger.info("Initializing connection '" + conn.name + "'.");
conn['robot'] = this;
this.connections[conn.name] = new Connection(conn);
}.bind(this));
@ -226,17 +204,40 @@ Robot.prototype.initDevices = function(devices) {
return;
}
// check that there are connections to use
if (!Object.keys(this.connections).length) {
throw new Error("No connections specified")
}
devices = [].concat(devices);
devices.forEach(function(device) {
device.robot = this;
if (this.devices[device.name]) {
var original = device.name;
device.name = Utils.makeUnique(original, Object.keys(this.devices));
Logger.warn("Device names must be unique. Renaming '" + original + "' to '" + device.name + "'");
}
if (typeof device.connection === 'string') {
if (this.connections[device.connection] == null) {
var str = "No connection found with the name " + device.connection + ".\n";
Logger.fatal(str);
process.emit('SIGINT');
}
device.connection = this.connections[device.connection];
} else {
for (var conn in this.connections) {
device.connection = this.connections[conn];
break;
}
}
device.adaptor = device.connection.adaptor;
Logger.info("Initializing device '" + device.name + "'.");
device['robot'] = this;
this.devices[device.name] = new Device(device);
}.bind(this));
@ -365,142 +366,6 @@ Robot.prototype.halt = function(callback) {
this.running = false;
};
// Public: Initialize an adaptor and adds it to @robot.adaptors
//
// adaptorName - module name of adaptor to require
// connection - the Connection that requested the adaptor be required
//
// Returns the adaptor
Robot.prototype.initAdaptor = function(adaptorName, connection, opts) {
if (opts == null) {
opts = {};
}
var adaptor = this.requireAdaptor(adaptorName, opts).adaptor({
name: adaptorName,
connection: connection,
extraParams: opts
});
if (process.env.NODE_ENV === 'test' && !CYLON_TEST) {
var testAdaptor = this.requireAdaptor('test').adaptor({
name: adaptorName,
connection: connection,
extraParams: opts
});
Utils.proxyTestStubs(adaptor.commands, testAdaptor);
for (var prop in adaptor) {
if (typeof adaptor[prop] === 'function' && !testAdaptor[prop]) {
testAdaptor[prop] = function() { return true; };
}
}
return testAdaptor;
} else {
return adaptor;
}
};
// Public: Requires a hardware adaptor and adds it to @robot.adaptors
//
// adaptorName - module name of adaptor to require
//
// Returns the module for the adaptor
Robot.prototype.requireAdaptor = function(adaptorName, opts) {
if (this.adaptors[adaptorName] == null) {
var moduleName = opts.module || adaptorName;
this.registerAdaptor("cylon-" + moduleName, adaptorName);
this.adaptors[adaptorName].register(this);
}
return this.adaptors[adaptorName];
};
// Public: Registers an Adaptor with the Robot
//
// moduleName - name of the Node module to require
// adaptorName - name of the adaptor to register the moduleName under
//
// Returns the registered module name
Robot.prototype.registerAdaptor = function(moduleName, adaptorName) {
if (this.adaptors[adaptorName] == null) {
try {
return this.adaptors[adaptorName] = require(moduleName);
} catch (e) {
if (e.code === "MODULE_NOT_FOUND") {
missingModuleError(moduleName);
} else {
throw e;
}
}
}
};
// Public: Init a hardware driver
//
// driverName - driver name
// device - the Device that requested the driver be initialized
// opts - object containing options when initializing driver
//
// Returns the new driver
Robot.prototype.initDriver = function(driverName, device, opts) {
if (opts == null) {
opts = {};
}
var driver = this.requireDriver(driverName).driver({
name: driverName,
device: device,
extraParams: opts
});
if (process.env.NODE_ENV === 'test' && !CYLON_TEST) {
var testDriver = this.requireDriver('test').driver({
name: driverName,
device: device,
extraParams: opts
});
return Utils.proxyTestStubs(driver.commands, testDriver);
} else {
return driver;
}
};
// Public: Requires module for a driver and adds it to @robot.drivers
//
// driverName - module name of driver to require
//
// Returns the module for driver
Robot.prototype.requireDriver = function(driverName) {
if (this.drivers[driverName] == null) {
this.registerDriver("cylon-" + driverName, driverName);
this.drivers[driverName].register(this);
}
return this.drivers[driverName];
};
// Public: Registers an Driver with the Robot
//
// moduleName - name of the Node module to require
// driverName - name of the driver to register the moduleName under
//
// Returns the registered module name
Robot.prototype.registerDriver = function(moduleName, driverName) {
if (this.drivers[driverName] == null) {
try {
return this.drivers[driverName] = require(moduleName);
} catch (e) {
if (e.code === "MODULE_NOT_FOUND") {
missingModuleError(moduleName);
} else {
throw e;
}
}
}
};
// Public: Returns basic info about the robot as a String
//
// Returns a String

1
lib/test/loopback.js
View File

@ -27,4 +27,5 @@ Loopback.prototype.disconnect = function(callback) {
callback();
};
Loopback.adaptors = ['loopback'];
Loopback.adaptor = function(opts) { return new Loopback(opts); };

5
lib/test/ping.js
View File

@ -34,6 +34,5 @@ Ping.prototype.halt = function(callback) {
callback();
};
Ping.driver = function(opts) {
return new Ping(opts);
};
Ping.drivers = ['ping'];
Ping.driver = function(opts) { return new Ping(opts); };

1
lib/test/test-adaptor.js
View File

@ -19,4 +19,5 @@ module.exports = TestAdaptor = function TestAdaptor() {
Utils.subclass(TestAdaptor, Adaptor);
TestAdaptor.adaptors = ['test'];
TestAdaptor.adaptor = function(opts) { return new TestAdaptor(opts); };

1
lib/test/test-driver.js
View File

@ -19,4 +19,5 @@ module.exports = TestDriver = function TestDriver() {
Utils.subclass(TestDriver, Driver);
TestDriver.drivers = ['test'];
TestDriver.driver = function(opts) { return new TestDriver(opts); };

24
spec/lib/device.spec.js
View File

@ -19,23 +19,28 @@ describe("Device", function() {
driver = new Ping({
name: 'driver',
device: { connection: connection, port: 13 }
device: { connection: connection, pin: 13 },
connection: connection
});
driver.cmd = spy();
driver.string = "";
driver.robot = spy();
initDriver = stub(robot, 'initDriver').returns(driver);
initDriver = stub(Device.prototype, 'initDriver').returns(driver);
device = new Device({
robot: robot,
name: "ping",
pin: 13,
connection: 'loopback'
connection: connection
});
});
afterEach(function() {
initDriver.restore();
});
describe("constructor", function() {
it("sets @robot to the passed robot", function() {
expect(device.robot).to.be.eql(robot);
@ -56,7 +61,6 @@ describe("Device", function() {
it("asks the Robot to init a driver", function() {
expect(device.driver).to.be.eql(driver);
expect(initDriver).to.be.calledOnce
initDriver.restore();
});
it("does not override existing functions", function() {
@ -158,16 +162,4 @@ describe("Device", function() {
expect(json.commands).to.be.eql(Object.keys(driver.commands));
});
});
describe("#determineConnection", function() {
it("returns the connection with the given name from the Robot", function() {
expect(device.determineConnection("loopback")).to.be.eql(connection);
});
});
describe("#defaultConnection", function() {
it("returns the first connection found on the robot", function() {
expect(device.defaultConnection()).to.be.eql(connection);
});
});
});

18
spec/lib/driver.spec.js
View File

@ -7,17 +7,22 @@ var Driver = source("driver"),
Utils = source('utils');
describe("Driver", function() {
var device, driver;
var connection, device, driver;
beforeEach(function() {
connection = {
adaptor: 'adaptor'
};
device = {
connection: {},
connection: connection,
emit: spy()
};
driver = new Driver({
name: 'driver',
device: device
device: device,
connection: connection
});
});
@ -44,13 +49,14 @@ describe("Driver", function() {
it("sets @interval to 10ms by default, or the provided value", function() {
expect(driver.interval).to.be.eql(10);
driver = new Driver({
name: 'driver',
device: device,
extraParams: {
interval: 2000
}
interval: 2000,
connection: { }
});
expect(driver.interval).to.be.eql(2000);
});
});

56
spec/lib/registry.spec.js Normal file
View File

@ -0,0 +1,56 @@
"use strict";
var Registry = source('registry');
var path = './../spec/support/mock_module.js';
var module = require('./../support/mock_module.js')
describe("Registry", function() {
var original;
beforeEach(function() {
original = Registry.data;
Registry.data = {};
});
afterEach(function() {
Registry.data = original;
})
describe("#register", function() {
it("adds the supplied module to the Registry", function() {
expect(Registry.data).to.be.eql({});
Registry.register(path);
expect(Registry.data).to.be.eql({
"./../spec/support/mock_module.js": {
module: module,
drivers: ['test-driver'],
adaptors: ['test-adaptor']
}
});
});
});
describe("#findByAdaptor", function() {
beforeEach(function() {
Registry.register(path)
});
it("finds the appropriate module containing the adaptor", function() {
expect(Registry.findByAdaptor('test-adaptor')).to.be.eql(module);
});
});
describe("#findByDriver", function() {
beforeEach(function() {
Registry.register(path)
});
it("finds the appropriate module containing the driver", function() {
expect(Registry.findByDriver('test-driver')).to.be.eql(module);
});
});
});

12
spec/lib/robot.spec.js
View File

@ -59,14 +59,6 @@ describe("Robot", function() {
expect(robot.devices).to.be.eql({});
});
it("sets @adaptors to an object containing all adaptors the Robot knows of", function() {
expect(robot.adaptors).to.have.keys(["loopback", "test"]);
});
it("sets @drivers to an object containing all drivers the Robot knows of", function() {
expect(robot.drivers).to.have.keys(["ping", "test"]);
});
it("sets @work to the passed work function", function() {
expect(robot.work).to.be.eql(work);
});
@ -277,7 +269,9 @@ describe("Robot", function() {
var bot;
beforeEach(function() {
bot = new Robot();
bot = new Robot({
connection: { name: 'loopback', adaptor: 'loopback' }
});
});
context("when not passed anything", function() {

7
spec/support/mock_module.js Normal file
View File

@ -0,0 +1,7 @@
// A mock Cylon module for use in internal testing.
"use strict";
module.exports = {
adaptors: [ 'test-adaptor' ],
drivers: [ 'test-driver' ]
};