Merge pull request #152 from uProxy/dev

v23

Author: iislucas

Gruntfile.coffee

@@ -46,37 +46,54 @@ taskManager.add 'copypasteFreedomChat', [
 ]
 
 # Create unit test code
-taskManager.add 'browserify_specs', [
+taskManager.add 'browserifySpecs', [
   'base'
   'browserify:arraybuffersSpec'
   'browserify:handlerSpec'
   'browserify:buildToolsTaskmanagerSpec'
   'browserify:loggingSpec'
   'browserify:loggingProviderSpec'
-  'browserify:webrtcSpec'
+  'browserify:peerconnectionSpec'
+  'browserify:datachannelSpec'
+  'browserify:queueSpec'
+]
+
+# Create unit test code
+taskManager.add 'browserifyCovSpecs', [
+  'base'
+  'browserify:arraybuffersCovSpec'
+  'browserify:handlerCovSpec'
+  'browserify:buildToolsTaskmanagerCovSpec'
+  'browserify:loggingCovSpec'
+  'browserify:loggingProviderCovSpec'
+  'browserify:peerconnectionCovSpec'
+  'browserify:datachannelCovSpec'
+  'browserify:queueCovSpec'
 ]
 
 # Run unit tests
 taskManager.add 'unit_test', [
-  'browserify_specs',
+  'browserifySpecs',
   'jasmine:arraybuffers'
   'jasmine:handler'
   'jasmine:buildTools'
   'jasmine:logging'
   'jasmine:loggingProvider'
   'jasmine:webrtc'
+  'jasmine:queue'
 ]
 
 # Run unit tests to produce coverage; these are separate from unit_tests because
 # they make tests hard to debug and fix.
 taskManager.add 'coverage', [
-  'browserify_specs'
+  'browserifyCovSpecs'
   'jasmine:arraybuffersCov'
   'jasmine:handlerCov'
   'jasmine:buildToolsCov'
   'jasmine:loggingCov'
   'jasmine:loggingProviderCov'
   'jasmine:webrtcCov'
+  'jasmine:queueCov'
 ]
 
 # Run unit tests
@@ -200,17 +217,29 @@ module.exports = (grunt) ->
       loggingProviderCov: Rule.addCoverageToSpec(Rule.jasmineSpec 'loggingprovider')
       webrtc: Rule.jasmineSpec 'webrtc'
       webrtcCov: Rule.addCoverageToSpec(Rule.jasmineSpec 'webrtc')
+      queue: Rule.jasmineSpec 'queue'
+      queueCov: Rule.addCoverageToSpec(Rule.jasmineSpec 'queue')
 
     browserify:
       # Browserify freedom-modules in the library
       loggingProvider: Rule.browserify 'loggingprovider/freedom-module'
       # Browserify specs
       arraybuffersSpec: Rule.browserifySpec 'arraybuffers/arraybuffers'
+      arraybuffersCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'arraybuffers/arraybuffers')
       buildToolsTaskmanagerSpec: Rule.browserifySpec 'build-tools/taskmanager'
+      buildToolsTaskmanagerCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'build-tools/taskmanager')
       handlerSpec: Rule.browserifySpec 'handler/queue'
+      handlerCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'handler/queue')
       loggingProviderSpec: Rule.browserifySpec 'loggingprovider/loggingprovider'
+      loggingProviderCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'loggingprovider/loggingprovider')
       loggingSpec: Rule.browserifySpec 'logging/logging'
-      webrtcSpec: Rule.browserifySpec 'webrtc/peerconnection'
+      loggingCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'logging/logging')
+      peerconnectionSpec: Rule.browserifySpec 'webrtc/peerconnection'
+      peerconnectionCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'webrtc/peerconnection')
+      datachannelSpec: Rule.browserifySpec 'webrtc/datachannel'
+      datachannelCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'webrtc/datachannel')
+      queueSpec: Rule.browserifySpec 'queue/queue'
+      queueCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'queue/queue')
       # Browserify sample apps main freedom module and core environments
       copypasteFreedomChatFreedomModule: Rule.browserify 'samples/copypaste-freedom-chat/freedom-module'
       copypasteFreedomChatMain: Rule.browserify 'samples/copypaste-freedom-chat/main.core-env'

package.json

@@ -1,7 +1,7 @@
 {
   "name": "uproxy-lib",
   "description": "Shared libraries for uProxy projects.",
-  "version": "20.0.5",
+  "version": "23.0.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/uProxy/uproxy-lib"

src/build-tools/common-grunt-rules.ts

@@ -39,6 +39,7 @@ export interface BrowserifyRule {
   src :string[];
   dest :string;
   options ?:{
+    transform ?:Object[][];
     debug ?:boolean;
   };
 }
@@ -59,6 +60,7 @@ export interface CopyRule {
 export class Rule {
   constructor(public config :RuleConfig) {}
 
+  // Note: argument is modified (and returned for conveniece);
   public addCoverageToSpec(spec:JasmineRule) :JasmineRule {
     var basePath = path.dirname(spec.options.outfile);
 
@@ -96,18 +98,26 @@ export class Rule {
   // Grunt browserify target creator
   public browserify(filepath:string, options = {
         browserifyOptions: { standalone: 'browserified_exports' }
-      }) : BrowserifyRule {
+      }) :BrowserifyRule {
     return {
       src: [ path.join(this.config.devBuildPath, filepath + '.js') ],
       dest: path.join(this.config.devBuildPath, filepath + '.static.js'),
       options: options
     };
   }
 
+  // Note: argument is modified (and returned for conveniece);
+  public addCoverageToBrowserify(rule:BrowserifyRule) :BrowserifyRule {
+    if(!rule.options.transform) {
+      rule.options.transform = [];
+    }
+    rule.options.transform.push(
+      ['browserify-istanbul', { ignore: ['**/mocks/**', '**/*.spec.js'] }]);
+    return rule
+  }
+
   // Grunt browserify target creator, instrumented for istanbul
   public browserifySpec(filepath:string, options = {
-        transform: [['browserify-istanbul',
-                    { ignore: ['**/mocks/**', '**/*.spec.js'] }]],
         browserifyOptions: { standalone: 'browserified_exports' }
       }) : BrowserifyRule {
     return {

src/handler/queue.ts

@@ -23,6 +23,8 @@
 // CONSIDER: This is kind of similar to functional parsing. May be good to
 // formalize the relationship in comments here.
 
+import baseQueue = require('../queue/queue');
+
 // The |QueueFeeder| is the abstraction for events to be handled.
 export interface QueueFeeder<Feed,Result> {
   // Number of things in the queue to be handled.
@@ -160,7 +162,7 @@ class PendingPromiseHandler<T,T2> {
 export class Queue<Feed,Result>
     implements QueueFeeder<Feed,Result>, QueueHandler<Feed,Result> {
   // The queue of things to handle.
-  private queue_ :PendingPromiseHandler<Feed, Result>[] = [];
+  private queue_ = new baseQueue.Queue<PendingPromiseHandler<Feed, Result>>();
 
   // Handler function for things on the queue. When null, things queue up.
   // When non-null, gets called on the thing to handle. When set, called on

src/queue/queue.spec.ts

@@ -0,0 +1,46 @@
+/// <reference path='../../../third_party/typings/jasmine/jasmine.d.ts' />
+
+import queue = require('./queue');
+import Queue = queue.Queue;
+
+describe('Base Queue', function() {
+  var queue :Queue<string>;
+
+  beforeEach(() => {
+    queue = new Queue<string>();
+  });
+
+  it('New queue has length = 0', function() {
+    expect(queue.length).toBe(0);
+  });
+
+  it('3 items makes length = 3', function() {
+    queue.push('A');
+    queue.push('BB');
+    queue.push('CCC');
+    expect(queue.length).toBe(3);
+  });
+
+  it('3 items and then clearing makes length = 0', function() {
+    queue.push('A');
+    queue.push('BB');
+    queue.push('CCC');
+    while (queue.length > 0) {
+      queue.shift();
+    }
+    expect(queue.length).toBe(0);
+  });
+
+  it('3 items come out in order', function() {
+    queue.push('A');
+    queue.push('BBB');
+    queue.push('CCCCC');
+    expect(queue.length).toBe(3);
+    expect(queue.shift()).toEqual('A');
+    expect(queue.length).toBe(2);
+    expect(queue.shift()).toEqual('BBB');
+    expect(queue.length).toBe(1);
+    expect(queue.shift()).toEqual('CCCCC');
+    expect(queue.length).toBe(0);
+  });
+});  // describe('Base Queue', ... )

src/queue/queue.ts

@@ -0,0 +1,43 @@
+// This file defines a basic queue data structure, providing
+// the standard Array push(), shift(), and length attributes,
+// but with O(1) operation.
+
+// Private helper class.
+class Cell<T> {
+  public next :Cell<T> = null;
+  constructor(public item:T) {}
+}
+
+export class Queue<T> {
+  private back_ :Cell<T> = null;
+  private front_ :Cell<T> = null;
+  public length :number = 0;
+
+  constructor() {}
+
+  // Add an item to the back of the queue.
+  public push = (item:T) : void => {
+    var cell = new Cell<T>(item);
+    if (this.length > 0) {
+      this.back_.next = cell;
+    } else {
+      // The queue was empty, so set both pointers.
+      this.front_ = cell;
+    }
+    this.back_ = cell;
+    this.length++;
+  }
+
+  // Remove and return the front element.
+  public shift = () : T => {
+    var dequeued = this.front_;
+    // If this.front_ is this.back_, then getNext() returns null.
+    this.front_ = dequeued.next;
+    dequeued.next = null;  // Just to help the garbage collector.
+    this.length--;
+    if (this.length === 0) {
+      this.back_ = null;
+    }
+    return dequeued.item;
+  }
+}  // class Queue

src/samples/copypaste-freedom-chat/freedom-module.ts

@@ -3,9 +3,9 @@
 
 import logging = require('../../logging/logging');
 
+import signals = require('../../webrtc/signals');
 import peerconnection = require('../../webrtc/peerconnection');
 import PeerConnection = peerconnection.PeerConnection;
-import SignallingMessage = peerconnection.SignallingMessage;
 import DataChannel = peerconnection.DataChannel;
 import Data = peerconnection.Data;
 
@@ -35,12 +35,12 @@ export function connectDataChannel(d:DataChannel) {
   });
 }
 
-export function makePeerConnection() : PeerConnection<SignallingMessage> {
-  var pc :PeerConnection<SignallingMessage> =
+export function makePeerConnection() : PeerConnection<signals.Message> {
+  var pc :PeerConnection<signals.Message> =
       peerconnection.createPeerConnection(pcConfig);
 
-  pc.signalForPeerQueue.setSyncHandler((signal:SignallingMessage) => {
-    parentModule.emit('signalForPeer', signal);
+  pc.signalForPeerQueue.setSyncHandler((message:signals.Message) => {
+    parentModule.emit('signalForPeer', message);
   });
 
   pc.onceConnected.then(() => {
@@ -62,7 +62,7 @@ export function makePeerConnection() : PeerConnection<SignallingMessage> {
   return pc;
 }
 
-export var pc :PeerConnection<SignallingMessage>;
+export var pc :PeerConnection<signals.Message>;
 
 parentModule.on('start', () => {
   pc = makePeerConnection();
@@ -82,9 +82,9 @@ parentModule.on('start', () => {
 // Receive signalling channel messages from the UI.
 // If pc doesn't exist yet then we are responding to the remote
 // peer's initiation.
-parentModule.on('signalFromPeer', (signal:SignallingMessage) => {
+parentModule.on('signalFromPeer', (message:signals.Message) => {
   if (pc === undefined) {
     pc = makePeerConnection();
   }
-  pc.handleSignalMessage(signal);
+  pc.handleSignalMessage(message);
 });

src/samples/simple-freedom-chat/freedom-module.ts

@@ -3,9 +3,9 @@
 
 import logging = require('../../logging/logging');
 
+import signals = require('../../webrtc/signals');
 import peerconnection = require('../../webrtc/peerconnection');
 import PeerConnection = peerconnection.PeerConnection;
-import SignallingMessage = peerconnection.SignallingMessage;
 import DataChannel = peerconnection.DataChannel;
 import Data = peerconnection.Data;
 
@@ -30,7 +30,7 @@ function connectDataChannel(name:string, d:DataChannel) {
           d.toString());
     });
     d.dataFromPeerQueue.setSyncHandler((data:Data) => {
-      log.info(name + ': dataFromPeer: ' + JSON.stringify(data));
+      log.info('%1: dataFromPeer: %2', name, data);
       // Handle messages received on the datachannel(s).
       parentFreedomModule.emit('receive' + name, {
         message: data.str
@@ -49,7 +49,7 @@ function makePeerConnection(name:string) {
       urls: ['stun:stun.l.google.com:19302']},
       {urls: ['stun:stun1.l.google.com:19302']}]
   };
-  var pc :PeerConnection<SignallingMessage> =
+  var pc :PeerConnection<signals.Message> =
     peerconnection.createPeerConnection(pcConfig, name);
   pc.onceConnecting.then(() => { log.info(name + ': connecting...'); });
   pc.onceConnected.then(() => {
@@ -68,18 +68,18 @@ function makePeerConnection(name:string) {
   return pc;
 }
 
-var a :PeerConnection<SignallingMessage> = makePeerConnection('A');
-var b :PeerConnection<SignallingMessage> = makePeerConnection('B')
+var a :PeerConnection<signals.Message> = makePeerConnection('A');
+var b :PeerConnection<signals.Message> = makePeerConnection('B')
 
 // Connect the two signalling channels. Normally, these messages would be sent
 // over the internet.
-a.signalForPeerQueue.setSyncHandler((signal:SignallingMessage) => {
-  log.info('a: sending signal to b.');
-  b.handleSignalMessage(signal);
+a.signalForPeerQueue.setSyncHandler((message:signals.Message) => {
+  log.info('a: sending signalling message to b.');
+  b.handleSignalMessage(message);
 });
-b.signalForPeerQueue.setSyncHandler((signal:SignallingMessage) => {
-  log.info('b: sending signal to a.');
-  a.handleSignalMessage(signal);
+b.signalForPeerQueue.setSyncHandler((message:signals.Message) => {
+  log.info('b: sending signalling message to a.');
+  a.handleSignalMessage(message);
 });
 
 // Negotiate a peerconnection. Once negotiated, enable the UI and add