coolerator.vision 0.2.4 → 0.2.5

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.2.5

data/coolerator.vision.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{coolerator.vision}
-  s.version = "0.2.4"
+  s.version = "0.2.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Corey Innis"]
-  s.date = %q{2009-11-13}
+  s.date = %q{2009-11-16}
   s.description = %q{A Rails plugin}
   s.email = %q{corey@coolerator.net}
   s.extra_rdoc_files = [

data/public/javascripts/vendor/coolerator/coolerator.base.js

@@ -1,5 +1,4 @@
 (function($) {
-  // VERSION 0.1.0
   // $.noConflict();
 
   Coolerator = {

data/public/javascripts/vendor/coolerator/coolerator.filter.js

@@ -1,57 +1,107 @@
 (function($) {
   $.extend(Coolerator, {
     Filters : {
-      global : [],
-      scoped : {},
+      count : function count() {
+        return __count__;
+      },
 
-      get : function get(scope) {
-        return $.merge($.makeArray(this.global), $.makeArray(this.scoped[scope]));
-      }
-    },
+      clear : function clear() {
+        __database__ = {};
+        __count__    = 0;
+      },
 
-    Filter : function Filter() {
-      var scope  = ['*'];
-      var filter = this;
+      prepare : function prepare() {
+        if(2 !== arguments.length) {
+          throw("InvalidArgumentException");
+        }
 
-      if(arguments.length) {
-        var first = arguments[0];
+        var view  = arguments[0];
+        var scope = arguments[1];
 
-        if('object' === typeof first) {
-          scope  = $.isArray(first.scope) ? first.scope : [first.scope || '*'];
+        if('object' !== typeof view || 'string' !== typeof scope) {
+          throw("InvalidArgumentException");
+        }
+
+        $.each(view, function prepare_views(name, content) {
+          view[name] = $(content);
+        });
 
-          filter = {
-            label  : first.label,
-            before : (first.before || function no_op() {}),
-            after  : (first.after  || function no_op() {})
-          };
+        var filters = retrieve(scope);
+        function before() {
+          $.each(filters, function(i, filter) {
+            filter.before(view);
+          });
+
+          return { after : after };
         }
-        else {
-          scope = arguments;
+
+        function after() {
+          $.each(filters, function(i, filter) {
+            filter.after(view);
+          });
+
+          return { before : before };
         }
+
+        return {
+          before : before,
+          after  : after
+        };
       }
+    },
 
-      $.each(scope, function(i, selector) {
-        if(selector === '*') {
-          Coolerator.Filters.global.push(filter);
-        }
-        else {
-          Coolerator.Filters.scoped[selector || '*'] = $.merge(Coolerator.Filters.scoped[selector || '*'] || [], [filter]);
-        }
+    Filter : function Filter() {
+      var scopes = arguments.length ? arguments : ['*'];
+      var filter = {
+        before : no_op,
+        after  : no_op
+      }
+
+      $.each(scopes, function(i, scope) {
+        store(scope, filter);
       });
-    }
-  });
 
-  $.extend(Coolerator.Filter.prototype, {
-    before : function before(fn) {
-      if('function' == typeof fn) {
-        this.before = fn;
+      function before(fn) {
+        filter.before = fn;
+        return { after : after };
       }
-    },
 
-    after : function after(fn) {
-      if('function' == typeof fn) {
-        this.after = fn;
+      function after(fn) {
+        filter.after = fn;
+        return { before : before };
       }
+
+      return {
+        before : before,
+        after  : after
+      };
     }
   });
+
+
+  // private...................................................................
+
+  var __count__    = 0;
+  var __database__ = {};
+
+  function no_op() {}
+
+  function store(scope, filter) {
+    if('object' === typeof scope) {
+      filter = scope;
+      scope  = '*';
+    }
+
+    __database__[scope] = __database__[scope] || [];
+    __database__[scope].push(filter);
+    __count__ += 1;
+  }
+
+  function retrieve(scope) {
+    if('*' === scope) {
+      return __database__['*'] || [];
+    }
+
+    return $.merge(__database__['*'] || [], __database__[scope] || []);
+  }
 })(jQuery);

data/public/javascripts/vendor/coolerator/coolerator.view.js

@@ -1,85 +1,83 @@
 (function($) {
+  var __database__ = {
+    collections : {},
+    instances   : {}
+  };
+
   $.extend(Coolerator, {
-    Views : {},
+    Views : {
+      get : function get(classifier) {
+        if( ! classifier || /\s+/.test(classifier)) {
+          throw("InvalidArgumentException");
+        }
+
+        return __database__.collections[classifier];
+      }
+    },
 
     View : function View(classifier) {
+      if( ! classifier || /\s+/.test(classifier)) {
+        throw("InvalidArgumentException");
+      }
+
       this.classifier = classifier;
 
-      $.extend(this, {
-        instance : {
-          content : function content(builder, attributes) {
-            var html_attributes = attributes.classifier ? { 'class' : attributes.classifier } : {};
+      __database__.collections[this.classifier] = this;
+      __database__.instances  [this.classifier] = {
+        content : function content(builder, attributes) {
+          var html_attributes = attributes.classifier ? { 'class' : attributes.classifier } : {};
 
-            with(builder) {
-              div(html_attributes);
-            }
-          },
+          with(builder) {
+            div(html_attributes);
+          }
+        },
 
-          methods : {
-            initialize : function initialize() {
-              if(this.content) {
-                this.html(this.content);
-              }
+        methods : {
+          initialize : function initialize() {
+            if(this.content) {
+              this.html(this.content);
             }
           }
         }
-      });
-
-      Coolerator.Views[classifier] = this;
+      };
     }
   });
 
   $.extend(Coolerator.View.prototype, {
-    cache : {},
+    subscribe : function subscribe(fn) {
+      Coolerator.Registrar.subscribe(this, fn);
+    },
 
     extend : function extend(extension) {
-      var self = this;
+      var instance = extension.instance || {};
+      var existing = __database__.instances[this.classifier];
+      delete extension.instance;
 
-      $.each(extension.instance.methods, function(name, fn) {
-        if(self.instance.methods[name]) {
-          var superb = self.instance.methods[name];
+      $.each(instance.methods || {}, function(name, fn) {
+        var superb = existing.methods[name];
+
+        if(superb) {
           function sup() {
             var args = $.makeArray(arguments);
             superb.apply(args.shift(), args);
           }
+
           $.extend(fn, { 'super' : sup });
         }
       });
 
-      $.extend(true, this.instance, extension.instance);
-      if(extension.collection) {
-        $.extend(true, this, extension.collection.methods, extension.collection.configuration);
-      }
-    },
-
-    subscribe : function subscribe(callback) {
-      var self = this;
-      callback = callback.toString().match(Coolerator.REGEX.FUNCTION_BODY)[1];
-      callback = new Function('registrar', 'with(registrar) { ' + callback + ' } ;');
-
-      Coolerator.Registrar.subscribe(self, callback);
+      $.extend(true, __database__.instances[this.classifier], instance);
+      $.extend(true, this, extension);
     },
 
     build : function build(attributes) {
-      if(this.cache.instance) {
-        return this.cache.instance;
-      }
-
-      var result = Prez.build(this.instance, $.extend({ collection: this, classifier : this.classifier }, (attributes || {})));
-
-      // TODO: consider making a call to view.subscribe
-      function subscribe(callback) {
-        if(callback) {
-          callback = callback.toString().match(Coolerator.REGEX.FUNCTION_BODY)[1];
-          callback = new Function('registrar', 'with(registrar) { ' + callback + ' } ;');
-          Coolerator.Registrar.subscribe(result, callback);
-        }
-      }
+      // TODO: provide a template cacheing mechanism.
 
-      subscribe(result.subscribe);
+      var instance = __database__.instances[this.classifier];
+      var result   = Prez.build(instance, $.extend({ classifier : this.classifier }, (attributes || {})));
 
-      if(this.singleton) {
-        this.cache.instance = result;
+      if(result.subscribe) {
+        Coolerator.Registrar.subscribe(result, result.subscribe);
       }
 
       return result;

data/spec/javascripts/vendor/coolerator/coolerator.filter_spec.js

@@ -1,20 +1,274 @@
 //= require <support/spec_helper>
 
 Screw.Unit(function(c) { with(c) {
+  after(function() {
+    Coolerator.Filters.clear();
+  });
+
+  describe("an example", function() {
+    before(function() {
+      Coolerator.Filter('scope/one', 'scope/two')
+        .before(function(view) {
+          $.each(view, function(key, partial) {
+            partial.css('border', 'yellow');
+          });
+        })
+        .after(function(view) {
+          $.each(view, function(key, partial) {
+            partial.css('border', 'green');
+          });
+        });
+    });
+
+    it("behaves", function() {
+      var templates = { show : '<div>content</div>' };
+      var filters   = Coolerator.Filters.prepare(templates, 'scope/one');
+      expect(templates.show.jquery).to_not(be_undefined);
+
+      filters.before();
+      expect(templates.show.css('border')).to(match, 'yellow');
+
+      filters.after();
+      expect(templates.show.css('border')).to(match, 'green');
+    });
+  });
+
+  describe("Coolerator.Filters", function() {
+    it("is added to the Coolerator namespace", function() {
+      expect(typeof Coolerator.Filters).to(equal, 'object');
+    });
+
+    describe("methods", function() {
+      describe(".count", function() {
+        before(function() {
+          Coolerator.Filter({});
+          Coolerator.Filter({ scope : 'scope 1' });
+          Coolerator.Filter({ scope : 'scope 1' });
+          Coolerator.Filter({ scope : 'scope 2' });
+        });
+
+        it("returns the count of filters, regardless of scope", function() {
+          expect(Coolerator.Filters.count()).to(equal, 4);
+        });
+      });
+
+      describe(".clear", function() {
+        before(function() {
+          Coolerator.Filter({ label : 'clear' });
+        });
+
+        it("sets 'count' to 0", function() {
+          expect(Coolerator.Filters.count()).to(equal, 1);
+
+          Coolerator.Filters.clear();
+          expect(Coolerator.Filters.count()).to(equal, 0);
+        });
+      });
+
+      describe(".prepare", function() {
+        var view;
+
+        before(function() {
+          view = { show : '<div>content</div>' };
+        });
+
+        describe("argument handling", function() {
+          var filters;
+
+          context("with appropriate arguments", function() {
+            before(function() {
+              filters = Coolerator.Filters.prepare(view, '*');
+            });
+
+            it("converts the view 'partials' to jQuery objects", function() {
+              expect(view.show.jquery).to_not(be_undefined);
+            });
+
+            describe("the returned filter helper", function() {
+              it("defines #before", function() {
+                expect(filters.before).to_not(throw_exception);
+              });
+
+              it("defines #after", function() {
+                expect(filters.after).to_not(throw_exception);
+              });
+            });
+          });
+
+          context("with fewer than two", function() {
+            before(function() {
+              fn = function fn() {
+                Coolerator.Filters.prepare({});
+              };
+            });
+
+            it("throws an exception", function() {
+              expect(fn).to(throw_exception);
+            });
+          });
+
+          context("with more than two", function() {
+            before(function() {
+              fn = function fn() {
+                Coolerator.Filters.prepare({}, 'scope', 'something else');
+              };
+            });
+
+            it("throws an exception", function() {
+              expect(fn).to(throw_exception);
+            });
+          });
+
+          context("with an undefined 'view'", function() {
+            before(function() {
+              fn = function fn() {
+                Coolerator.Filters.prepare(undefined, 'scope');
+              };
+            });
+
+            it("throws an exception", function() {
+              expect(fn).to(throw_exception);
+            });
+          });
+
+          context("with an undefined 'scope'", function() {
+            before(function() {
+              fn = function fn() {
+                Coolerator.Filters.prepare({ show : '<div>content</div>' }, undefined);
+              };
+            });
+
+            it("throws an exception", function() {
+              expect(fn).to(throw_exception);
+            });
+          });
+        });
+      });
+    });
+  });
+
   describe("Coolerator.Filter", function() {
+    var filter;
+
     it("is added to the Coolerator namespace", function() {
       expect(typeof Coolerator.Filter).to(equal, 'function');
     });
 
-    context("when created with a configuration object", function() {
-      context("when the configuration :label exists", function() {
-        var filter = new Coolerator.Filter({
-          label : 'so cool!',
-          scope : 'everywhere'
+    describe("the returned object", function() {
+      before(function() {
+        filter = Coolerator.Filter();
+      });
+
+      it("is defined", function() {
+        expect(filter).to_not(be_undefined);
+      });
+
+      it("defines #before", function() {
+        expect(filter.before).to_not(be_undefined);
+      });
+
+      it("defines #after", function() {
+        expect(filter.after).to_not(be_undefined);
+      });
+    });
+
+    describe("argument handling", function() {
+      var called;
+
+      before(function() {
+        called = {
+          before : false,
+          after  : false
+        }
+      });
+
+      context("called with no scope", function() {
+        before(function() {
+          Coolerator.Filter()
+            .before(function(view) {
+              called.before = true;
+            })
+            .after(function(view) {
+              called.after = true;
+            });
+        });
+
+        it("adds the filter to the 'global' scope", function() {
+          Coolerator.Filters.prepare({}, '*')
+            .before()
+            .after();
+
+          expect(called.before).to(be_true);
+          expect(called.after ).to(be_true);
         });
+      });
+
+      context("called with a single scope", function() {
+        before(function() {
+          Coolerator.Filter('one')
+            .before(function(view) {
+              called.before = true;
+            })
+            .after(function(view) {
+              called.after = true;
+            });
+        });
+
+        it("adds the filter to the provided scope", function() {
+          Coolerator.Filters.prepare({}, 'one')
+            .before()
+            .after();
+
+          expect(called.before).to(be_true);
+          expect(called.after ).to(be_true);
+        });
+
+        it("does not add the filter to the global scope", function() {
+          Coolerator.Filters.prepare({}, '*')
+            .before()
+            .after();
+
+          expect(called.before).to(be_false);
+          expect(called.after ).to(be_false);
+        });
+      });
+
+      context("called with multiple scopes", function() {
+        before(function() {
+          Coolerator.Filter('one', 'two')
+            .before(function(view) {
+              called.before = true;
+            })
+            .after(function(view) {
+              called.after = true;
+            });
+        });
+
+        it("adds the filter to the first provided scope", function() {
+          Coolerator.Filters.prepare({}, 'one')
+            .before()
+            .after();
+
+          expect(called.before).to(be_true);
+          expect(called.after ).to(be_true);
+        });
+
+        it("adds the filter to the first provided scope", function() {
+          Coolerator.Filters.prepare({}, 'two')
+            .before()
+            .after();
+
+          expect(called.before).to(be_true);
+          expect(called.after ).to(be_true);
+        });
+
+        it("does not add the filter to the global scope", function() {
+          Coolerator.Filters.prepare({}, '*')
+            .before()
+            .after();
 
-        it("is created with a label", function() {
-          expect(Coolerator.Filters.get('everywhere')[0].label).to(equal, 'so cool!');
+          expect(called.before).to(be_false);
+          expect(called.after ).to(be_false);
         });
       });
     });

data/spec/javascripts/vendor/coolerator/coolerator.view_spec.js

@@ -3,96 +3,393 @@
 Screw.Unit(function(c) { with(c) {
   describe("Coolerator.Views", function() {
     it("is added to the Coolerator namespace", function() {
-      expect(Coolerator.Views).to_not(be_undefined);
+      expect(typeof Coolerator.Views).to(equal, 'object');
     });
 
-    describe("when creating a Coolerator.View", function() {
-      it("the View is added to the collection", function() {
-        var view = new Coolerator.View('oh, behave!');
-        expect(Coolerator.Views['oh, behave!']).to(equal, view);
+    describe("methods", function() {
+      describe(".get", function() {
+        context("with 'classifier' defined appropriately", function() {
+          context("when there is a match", function() {
+            it("returns the view", function() {
+              var view = new Coolerator.View('defined');
+              expect(Coolerator.Views.get('defined')).to(equal, view);
+            });
+          });
+
+          context("when there is no match", function() {
+            it("returns undefined", function() {
+              expect(Coolerator.Views.get('undefined')).to(be_undefined);
+            });
+          });
+        });
+
+        context("with 'classifier' as falsy", function() {
+          var fn;
+
+          it("throws an exception (with undefined)", function() {
+            fn = function fn() {
+              Coolerator.Views.get();
+            }
+            expect(fn).to(throw_exception);
+          });
+
+          it("throws an exception (with null)", function() {
+            fn = function fn() {
+              Coolerator.Views.get(null);
+            }
+            expect(fn).to(throw_exception);
+          });
+
+          it("throws an exception (with empty string)", function() {
+            fn = function fn() {
+              Coolerator.Views.get('');
+            }
+            expect(fn).to(throw_exception);
+          });
+
+          it("throws an exception (with 0)", function() {
+            fn = function fn() {
+              Coolerator.Views.get(0);
+            }
+            expect(fn).to(throw_exception);
+          });
+        });
       });
     });
   });
 
   describe("Coolerator.View", function() {
     it("is added to the Coolerator namespace", function() {
-      expect(Coolerator.View).to_not(be_undefined);
+      expect(typeof Coolerator.View).to(equal, 'function');
     });
 
-    describe("collection", function() {
-      it("is optional", function() {
-        var fn = function() {
-          var view = new Coolerator.View('one');
+    describe("constructor", function() {
+      var fn;
 
-          view.extend({
-            instance : {
-              methods : {}
-            }
+      context("with 'classifier' defined appropriately", function() {
+        var view;
+
+        before(function() {
+          view = new Coolerator.View('valid');
+        });
+
+        describe("the returned object", function() {
+          it("is a Coolerator.View instance", function() {
+            expect(view.constructor.name).to(equal, 'View');
           });
-        };
 
-        expect(fn).to_not(throw_exception);
-      });
-    });
+          it("defines 'classifier' as an attribute", function() {
+            expect(view.classifier).to(equal, 'valid');
+          });
+        });
 
-    describe("instance", function() {
-      describe("methods which are implemented in super and child objects", function() {
-        var view, other;
+        describe("updates to Coolerator.Views", function() {
+          it("stores the new view", function() {
+            expect(Coolerator.Views.get('valid')).to(equal, view);
+          });
+
+          it("overwrites an existing view of the same classifier", function() {
+            var over = new Coolerator.View('valid');
 
+            expect(Coolerator.Views.get('valid') == over).to(be_true);
+            expect(Coolerator.Views.get('valid') == view).to(be_false);
+          });
+        });
+      });
+
+      context("with 'classifier' defined with space(s)", function() {
         before(function() {
-          other = new Coolerator.View('other');
-          view  = new Coolerator.View('child');
+          fn = function fn() {
+            return new Coolerator.View('with spaces');
+          }
+        });
 
-          view.extend({
-            instance : {
-              methods : {
-                initialize : function initialize() {}
-              }
-            }
-          })
+        it("throws an exception", function() {
+          expect(fn).to(throw_exception);
+        });
+      });
+
+      context("with 'classifier' defined as falsy", function() {
+        it("throws an exception (with undefined)", function() {
+          fn = function fn() {
+            return new Coolerator.View();
+          }
+          expect(fn).to(throw_exception);
+        });
+
+        it("throws an exception (with null)", function() {
+          fn = function fn() {
+            return new Coolerator.View(null);
+          }
+          expect(fn).to(throw_exception);
         });
 
-        it("provides a mechanism for calling #super", function() {
-          var instance = view.build();
-          expect(instance.initialize.super).to(equal, other.instance.methods.initialize);
+        it("throws an exception (with empty string)", function() {
+          fn = function fn() {
+            return new Coolerator.View('');
+          }
+          expect(fn).to(throw_exception);
+        });
+
+        it("throws an exception (with 0)", function() {
+          fn = function fn() {
+            return new Coolerator.View(0);
+          }
+          expect(fn).to(throw_exception);
         });
       });
+    });
 
-      describe("when two or more Views implement the same method", function() {
-        var instance1, instance2;
+    describe("methods", function() {
+      var view;
 
-        before(function() {
-          view1 = new Coolerator.View('one');
+      before(function() {
+        view = new Coolerator.View('subscript');
+      });
 
-          view1.extend({
-            instance : {
-              methods : {
-                foo : function foo() {
-                  return "foo an instance of view1";
+      describe("#subscribe", function() {
+        context("given a function", function() {
+          it("executes the function with 'this' as the view", function() {
+            view.subscribe(function() {
+              expect(this).to(equal, view);
+            });
+          });
+
+          it("executes the function with a Coolerator.Registar subscription", function() {
+            view.subscribe(function(subscription) { with(subscription) {
+              expect(on ).to_not(be_undefined);
+              expect(use).to_not(be_undefined);
+            }});
+          });
+
+          it("[PENDING] executes the function after executing #extend, so other fields are available", function() {
+            // this does work, but it relies on jQuery's document ready event which makes it hard to test here.
+          });
+        });
+      });
+
+      describe("#extend", function() {
+        context("given an extension with non-instance arguments", function() {
+          it("extends the 'collection' object (the view)", function() {
+            function func() {};
+
+            view.extend({
+              conf : 'config',
+              func : func
+            });
+
+            expect(view.conf).to(equal, 'config');
+            expect(view.func).to(equal, func);
+          });
+
+          it("does not 'step on' other views", function() {
+            var view1 = new Coolerator.View('one');
+            var view2 = new Coolerator.View('two');
+
+            view1.extend({
+              foo : function foo() {
+                return 'foo on view one';
+              }
+            });
+
+            view2.extend({
+              foo : function foo() {
+                return 'foo on view two';
+              }
+            });
+
+            expect(view1.foo()).to(equal, 'foo on view one');
+            expect(view2.foo()).to(equal, 'foo on view two');
+          });
+        });
+
+        context("given an extension with an instance argument", function() {
+          it("does not extend the 'collection' object", function() {
+            view.extend({
+              instance : {
+                methods : {}
+              }
+            });
+
+            expect(view.instance).to(be_undefined);
+          });
+
+          it("extends built instances", function() {
+            view.extend({
+              instance : {
+                content : function content(builder) {
+                  builder.div('content');
+                },
+
+                methods : {
+                  label : function label() {
+                    return 'an instance';
+                  }
                 }
               }
-            }
+            });
+
+            expect(view.build().label()).to(equal, 'an instance');
           });
 
-          view2 = new Coolerator.View('two');
+          it("does not 'step on' other views", function() {
+            var view1 = new Coolerator.View('one');
+            var view2 = new Coolerator.View('two');
 
-           view2.extend({
-             instance : {
-               methods : {
-                 foo : function foo() {
-                   return "foo an instance of view2";
-                 }
-               }
-             }
-           });
+            view1.extend({
+              instance : {
+                methods : {
+                  foo : function foo() {
+                    return 'foo on view one';
+                  }
+                }
+              }
+            });
 
-           instance1 = view1.build();
-           instance2 = view2.build();
+            view2.extend({
+              instance : {
+                methods : {
+                  foo : function foo() {
+                    return 'foo on view two';
+                  }
+                }
+              }
+            });
+
+            expect(view1.build().foo()).to(equal, 'foo on view one');
+            expect(view2.build().foo()).to(equal, 'foo on view two');
+          });
+
+          describe("content (for the builder)", function() {
+            it("is defaulted to a simple <div />", function() {
+              view.extend({
+                instance : {}
+              });
+
+              var wrapper = $('<div></div>');
+                  wrapper.html(view.build());
+              expect(wrapper.html()).to(equal, '<div class="subscript"></div>');
+            });
+
+            describe("overwriting", function() {
+              it("is allowed", function() {
+                view.extend({
+                  instance : {
+                    content : function content(builder) {
+                      with(builder) {
+                        div({ id : 'custom' });
+                      }
+                    }
+                  }
+                });
+
+                var wrapper = $('<div></div>');
+                    wrapper.html(view.build());
+                expect(wrapper.html()).to(equal, '<div id="custom"></div>');
+              });
+            });
+          });
+
+          describe("methods", function() {
+            describe("#initialize", function() {
+              it("is called automatically", function() {
+                var called = false;
+
+                view.extend({
+                  instance : {
+                    methods : {
+                      initialize : function initialize() {
+                        called = true;
+                      }
+                    }
+                  }
+                });
+
+                view.build();
+                expect(called).to(be_true);
+              });
+
+              it("is defaulted to (optionally) write provided content to the instance", function() {
+                view.extend({
+                  instance : {}
+                });
+
+                expect(view.build().html()).to(equal, '');
+                expect(view.build({ content : 'hello there' }).html()).to(equal, 'hello there');
+              });
+
+              describe("overwriting", function() {
+                before(function() {
+                  view.extend({
+                    instance : {
+                      methods : {
+                        initialize : function initialize() {
+                          this.html('overwritten');
+                        }
+                      }
+                    }
+                  });
+                });
+
+                it("is allowed", function() {
+                  var instance = view.build();
+                  expect(instance.html()).to(equal, 'overwritten');
+                });
+
+                it("provides a mechanism for calling #super", function() {
+                  var instance = view.build();
+                  expect(typeof instance.initialize.super).to(equal, 'function');
+                });
+              });
+            });
+
+            describe("#subscribe", function() {
+              it("is called automatically, with 'this' as the instance and a Coolerator.Registar subscription as an argument", function() {
+                var called = false;
+                var callee = null;
+
+                view.extend({
+                  instance : {
+                    methods : {
+                      subscribe : function subscribe(subscription) {
+                        called = true;
+                        callee = this;
+
+                        with(subscription) {
+                          expect(on ).to_not(be_undefined);
+                          expect(use).to_not(be_undefined);
+                        }
+                      }
+                    }
+                  }
+                });
+
+                var instance = view.build();
+                expect(called).to(be_true);
+                expect(callee).to(equal, instance);
+              });
+            });
+          });
         });
+      });
+
+      describe("#build", function() {
+        it("returns an 'instance' of the view", function() {
+          view.extend({
+            instance : {
+              content : function content(builder) {
+                builder.div('content');
+              },
+
+              methods : {
+                label : function label() {
+                  return 'an instance';
+                }
+              }
+            }
+          });
 
-        it("allows them to coexist", function() {
-          expect(instance1.foo()).to(equal, "foo an instance of view1");
-          expect(instance2.foo()).to(equal, "foo an instance of view2");
+          expect(view.build().label()).to(equal, 'an instance');
         });
       });
     });

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: coolerator.vision
 version: !ruby/object:Gem::Version 
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors: 
 - Corey Innis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-13 00:00:00 -05:00
+date: 2009-11-16 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency