transistor 0.1.3 → 0.1.4

data/build/src/transistor.js

@@ -159,11 +159,11 @@ if (window.Transistor === undefined) {
 }
 
 (function (transistor) {
-    var Binder = (function () {
-        return function (array) {
-            var H, set, insert, update, remove;
+    var Binder, ArrayBinding;
 
-            H = (function () {
+    ArrayBinding = {
+        bindTo: function (array) {
+            var H = (function () {
                 return {
                     clear: function () {
                         for (;array.length !== 0;) {
@@ -179,21 +179,66 @@ if (window.Transistor === undefined) {
                         }
 
                         throw new Error("unknown id: " + id);
-                    },
+                    }
+                };
+            }());
+
+            return {
+                set: function (collection) {
+                    H.clear();
+
+                    if (collection !== undefined) {
+                        for (var i = 0 ; i < collection.length; i += 1) {
+                            array[i] = collection[i];
+                        }
+                    }
+                },
+                insert: function (entry) {
+                    if (entry !== undefined) {
+                        array.push(entry);
+                    }
+                },
+                update: function (id, entry) {
+                    if (id === undefined) {
+                        throw new Error("undefined id");
+                    }
+
+                    array[H.indexOfId(id)] = entry;
+                },
+                remove: function (id) {
+                    array.splice(H.indexOfId(id), 1);
+                }
+            };
+        }
+    };
+
+
+    Binder = (function () {
+        return function (binding) {
+            var validate, target;
+
+            if (Object.prototype.toString.call( binding ) === '[object Array]') {
+                target = ArrayBinding.bindTo(binding);
+            } else {
+                target = binding;
+            }
 
-                    expectCollection: function (args) {
+
+            validate = (function () {
+                return {
+                    collection: function (args) {
                         if (args.collection === undefined) {
                             throw new Error("undefined collection");
                         }
                     },
 
-                    expectEntry: function (args) {
+                    entry: function (args) {
                         if (args.entry === undefined) {
                             throw new Error("undefined entry");
                         }
                     },
 
-                    expectId: function (args) {
+                    id: function (args) {
                         if (args.id === undefined) {
                             throw new Error("undefined id");
                         }
@@ -201,34 +246,6 @@ if (window.Transistor === undefined) {
                 };
             }());
 
-            set = function (collection) {
-                H.clear();
-
-                if (collection !== undefined) {
-                    for (var i = 0 ; i < collection.length; i += 1) {
-                        array[i] = collection[i];
-                    }
-                }
-            };
-
-            insert = function (entry) {
-                if (entry !== undefined) {
-                    array.push(entry);
-                }
-            };
-
-            update = function (id, entry) {
-                if (id === undefined) {
-                    throw new Error("undefined id");
-                }
-
-                array[H.indexOfId(id)] = entry;
-            };
-
-            remove = function (id) {
-                array.splice(H.indexOfId(id), 1);
-            };
-
             return function (event, args) {
                 if (args === undefined) {
                     throw new Error("undefined arguments");
@@ -236,24 +253,24 @@ if (window.Transistor === undefined) {
 
                 switch (event) {
                 case 'init':
-                    set(args);
+                    target.set(args);
                     break;
                 case 'set':
-                    H.expectCollection(args);
-                    set(args.collection);
+                    validate.collection(args);
+                    target.set(args.collection);
                     break;
                 case 'insert':
-                    H.expectEntry(args);
-                    insert(args.entry);
+                    validate.entry(args);
+                    target.insert(args.entry);
                     break;
                 case 'update':
-                    H.expectId(args);
-                    H.expectEntry(args);
-                    update(args.id, args.entry);
+                    validate.id(args);
+                    validate.entry(args);
+                    target.update(args.id, args.entry);
                     break;
                 case 'remove':
-                    H.expectId(args);
-                    remove(args.id);
+                    validate.id(args);
+                    target.remove(args.id);
                     break;
                 }
             };

data/index.html

@@ -0,0 +1,41 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=utf-8">
+    <title>radiotower</title>
+    <!-- <script type="text/javascript" src="js/vendor/faye-browser-min.js"></script> -->
+    <!-- <script type="text/javascript" src="js/vendor/jsonp.js"></script> -->
+    <!-- <script type="text/javascript" src="js/transistor/radio.js"></script> -->
+    <!-- <script type="text/javascript" src="js/transistor/control.js"></script> -->
+    <!-- <script type="text/javascript" src="js/transistor/binder.js"></script> -->
+    <script type="text/javascript" src="build/src/transistor.js"></script>
+    <script type="text/javascript">
+
+      var control = Transistor.Control(
+        'http://localhost:9700',              // broadcaster
+        'e0745051ed75e95d1088986fedbde764',   // station uid
+        '26d47e42b5ce83a934725f5e18e01d2b'    // push token
+      )
+
+      var radio = Transistor.Radio(
+        'http://localhost:9703',              // station_finder
+        'e0745051ed75e95d1088986fedbde764',   // station uid
+        '4b9b62aae02f1f4fe079da7bcd0be00d'    // test/live token
+      );
+
+      // explicit listener function
+      radio.tune("about", function(event, args) {
+        console.log('about', event, args);
+      });
+
+      // bind channel to a local array
+      var news = [];
+      radio.tune("news", Transistor.Binder(news));
+
+      radio.turnOn();
+    </script>
+  </head>
+  <body>
+
+  </body>
+</html>

data/jake.yml

@@ -25,6 +25,9 @@ packages:
     - vendor/jsonp
     - transistor/control
 
+  transistor-backbone:
+    - transistor/backbone-collection.js
+
   transistor:
     - vendor/faye-browser-min
     - vendor/jsonp

data/js/transistor/backbone-collection.js

@@ -0,0 +1,100 @@
+/*global Backbone, _ */
+
+if (window.Transistor === undefined) {
+    window.Transistor = {};
+}
+
+(function (transistor) {
+    var BackboneCollection = (function () {
+        return function (radio, channel) {
+            var H, backbone_collection, collection_interface, binder;
+
+            H = (function () {
+                return {
+                };
+            }());
+
+            backbone_collection = new Backbone.Collection();
+
+            collection_interface = {
+                add: backbone_collection.add,
+                remove: backbone_collection.remove,
+                reset: backbone_collection.reset,
+                set: backbone_collection.set
+            };
+
+            (function (writer) {
+                var frozen = true,
+                    delegate = function (func) {
+                    writer[func] = (function (name) {
+                        return function () {
+                            if (frozen) {
+                                throw "BackboneCollection is not mutable by user.";
+                            } else {
+                                return collection_interface[name].apply(backbone_collection, arguments);
+                            }
+                        };
+                    }(func));
+                };
+
+                collection_interface.unfreeze = function () {
+                    frozen = false;
+                };
+
+                collection_interface.freeze = function () {
+                    frozen = true;
+                };
+
+                collection_interface.unfrozen = function (unfrozen_context) {
+                    collection_interface.unfreeze();
+                    unfrozen_context();
+                    collection_interface.freeze();
+                };
+
+                delegate('add');
+                delegate('remove');
+                delegate('reset');
+                delegate('set');
+            }(backbone_collection));
+
+            binder = transistor.Binder({
+                set: function (collection) {
+                    collection_interface.unfrozen(function () {
+                        var models = _.map(collection, function (entry) {
+                            return new Backbone.Model(entry);
+                        });
+                        backbone_collection.reset(models);
+                    });
+                },
+                insert: function (entry) {
+                    collection_interface.unfrozen(function () {
+                        backbone_collection.add(new Backbone.Model(entry));
+                    });
+                },
+                update: function (id, entry) {
+                    collection_interface.unfrozen(function () {
+                        var model = backbone_collection.get(id);
+                        model.clear({silent: true});
+                        model.set(entry);
+                    });
+                },
+                remove: function (id) {
+                    collection_interface.unfrozen(function () {
+                        var model = backbone_collection.get(id);
+                        backbone_collection.remove(model);
+                    });
+                }
+            });
+
+            radio.tune(channel, binder);
+
+            return backbone_collection;
+        };
+    }());
+
+    if (transistor.Backbone === undefined) {
+        transistor.Backbone = {};
+    }
+    transistor.Backbone.Collection = BackboneCollection;
+
+}(window.Transistor));

data/js/transistor/binder.js

@@ -0,0 +1,126 @@
+if (window.Transistor === undefined) {
+    window.Transistor = {};
+}
+
+(function (transistor) {
+    var Binder, ArrayBinding;
+
+    ArrayBinding = {
+        bindTo: function (array) {
+            var H = (function () {
+                return {
+                    clear: function () {
+                        for (;array.length !== 0;) {
+                            array.pop();
+                        }
+                    },
+
+                    indexOfId: function (id) {
+                        for (var i = 0; i < array.length; i += 1) {
+                            if (array[i].id === id) {
+                                return i;
+                            }
+                        }
+
+                        throw new Error("unknown id: " + id);
+                    }
+                };
+            }());
+
+            return {
+                set: function (collection) {
+                    H.clear();
+
+                    if (collection !== undefined) {
+                        for (var i = 0 ; i < collection.length; i += 1) {
+                            array[i] = collection[i];
+                        }
+                    }
+                },
+                insert: function (entry) {
+                    if (entry !== undefined) {
+                        array.push(entry);
+                    }
+                },
+                update: function (id, entry) {
+                    if (id === undefined) {
+                        throw new Error("undefined id");
+                    }
+
+                    array[H.indexOfId(id)] = entry;
+                },
+                remove: function (id) {
+                    array.splice(H.indexOfId(id), 1);
+                }
+            };
+        }
+    };
+
+
+    Binder = (function () {
+        return function (binding) {
+            var validate, target;
+
+            if (Object.prototype.toString.call( binding ) === '[object Array]') {
+                target = ArrayBinding.bindTo(binding);
+            } else {
+                target = binding;
+            }
+
+
+            validate = (function () {
+                return {
+                    collection: function (args) {
+                        if (args.collection === undefined) {
+                            throw new Error("undefined collection");
+                        }
+                    },
+
+                    entry: function (args) {
+                        if (args.entry === undefined) {
+                            throw new Error("undefined entry");
+                        }
+                    },
+
+                    id: function (args) {
+                        if (args.id === undefined) {
+                            throw new Error("undefined id");
+                        }
+                    }
+                };
+            }());
+
+            return function (event, args) {
+                if (args === undefined) {
+                    throw new Error("undefined arguments");
+                }
+
+                switch (event) {
+                case 'init':
+                    target.set(args);
+                    break;
+                case 'set':
+                    validate.collection(args);
+                    target.set(args.collection);
+                    break;
+                case 'insert':
+                    validate.entry(args);
+                    target.insert(args.entry);
+                    break;
+                case 'update':
+                    validate.id(args);
+                    validate.entry(args);
+                    target.update(args.id, args.entry);
+                    break;
+                case 'remove':
+                    validate.id(args);
+                    target.remove(args.id);
+                    break;
+                }
+            };
+        };
+    }());
+
+    transistor.Binder = Binder;
+
+}(window.Transistor));

data/js/transistor/control.js

@@ -0,0 +1,64 @@
+/*global JSONP */
+if (window.Transistor === undefined) {
+    window.Transistor = {};
+}
+
+(function (transistor) {
+
+    var Control = (function () {
+
+        return function (broadcaster, station_uid, token) {
+            var jsonp, set, insert, update, remove, command_url, send;
+
+            jsonp = JSONP();
+
+            set = function (channel, collection, cb) {
+                send(command_url('set', channel), {collection: collection}, cb);
+            };
+
+            insert = function (channel, entry, cb) {
+                send(command_url('insert', channel), {entry: entry}, cb);
+            };
+
+            update = function (channel, id, entry, cb) {
+                send(command_url('update', channel), {id: id, entry: entry}, cb);
+            };
+
+            remove = function (channel, id, cb) {
+                send(command_url('remove', channel), {id: id}, cb);
+            };
+
+            command_url = function (cmd, channel) {
+                var base = broadcaster + '/command/' + cmd + '/' + station_uid + '/' + token;
+
+                if (channel === undefined) {
+                    return base;
+                } else {
+                    return base + '/' + channel;
+                }
+            };
+
+            send = function (command_url, data, cb) {
+                if (cb === undefined) {
+                    cb = function (result) {};
+                }
+
+                if (data === undefined) {
+                    jsonp.get(command_url, {}, cb);
+                } else {
+                    jsonp.get(command_url, {data: JSON.stringify(data)}, cb);
+                }
+            };
+
+            return {
+                set: set,
+                insert: insert,
+                update: update,
+                remove: remove
+            };
+        };
+    }());
+
+    transistor.Control = Control;
+
+}(window.Transistor));