jim 0.1.2 → 0.2.0

data/test/fixtures/sammy-0.5.0/test/test_sammy_event_context.js

@@ -0,0 +1,252 @@
+(function($) {
+    with(QUnit) {
+      
+      var test_app = new Sammy.Application(function() {
+        this.silence_404 = true;
+        this.element_selector = '#main';
+      });
+      var test_context = new Sammy.EventContext(test_app, 'get', '#/test/:test', {test: 'hooray'});
+
+      context('Sammy', 'EventContext','init', {
+        before: function() {
+          this.app = test_app;
+          this.context = test_context;
+        }
+      })
+      .should('set app', function() {
+        deepEqual(this.context.app, this.app);
+      })
+      .should('set verb', function() {
+        equal(this.context.verb, 'get');
+      })
+      .should('set path', function() {
+        equal(this.context.path, '#/test/:test');
+      })
+      .should('set params', function() {
+        deepEqual(this.context.params, new Sammy.Object({test: 'hooray'}));
+      });
+      
+
+      context('Sammy', 'EventContext', 'redirect', {
+        before: function() {
+          this.app = test_app;
+          this.context = test_context;
+        },
+        after: function() {
+          window.location.hash = '#';
+        }
+      })
+      .should('set full location if url is provided', function() {
+        this.context.redirect('index.html#/boosh');
+        equal('#/boosh', window.location.hash);
+      })
+      .should('only set hash if location is prefixed with #', function() {
+        this.context.redirect('#/blah');
+        equal('#/blah', window.location.hash);
+      })
+      .should('join the arguments with / if more then one argument is provided', function() {
+        var boosh = 'boosh';
+        this.context.redirect('#', 'blah', boosh);
+        equal('#/blah/boosh', window.location.hash);
+      });
+
+
+      context('Sammy', 'EventContext', 'notFound', {
+        before: function() {
+          this.context = test_context;
+        }
+      })
+      .should('throw 404 error', function() {
+        var context = this.context;
+        raised(/404/, function() {
+          context.notFound();
+        });
+      });
+      
+      context('Sammy', 'EventContext', 'partial', {
+        before: function() {
+          this.app     = test_app;
+          this.context = test_context;
+        }
+      })
+      .should('pass contents to callback', function() {
+        var contents = '';
+        this.context.partial('fixtures/partial.html', function(data) { contents = data; });
+        soon(function () {
+          equal(contents, '<div class="test_partial">PARTIAL</div>');
+        }, this, 2);
+      })
+      .should('not run through template() if Sammy.Template is not present', function() {
+        var contents = '';
+        this.context.partial('fixtures/partial.template', {name: 'TEMPLATE!', class_name: 'test_template'}, function(data) { 
+          contents = data; 
+        });
+        soon(function () {
+          equal(contents, '<div class="<%= class_name %>"><%= name %></div>');
+        }, this, 2);
+      })
+      .should('run through template() if Sammy.Template _is_ present', function() {
+        var contents = '';
+        var app = new Sammy.Application(function() { this.element_selector = '#main'; });
+        app.use(Sammy.Template);
+        this.context = new app.context_prototype(app);
+        this.context.partial('fixtures/partial.template', {name: 'TEMPLATE!', class_name: 'test_template'}, function(data) { 
+          contents = data; 
+        });
+        soon(function () {
+          equal(contents, '<div class="test_template">TEMPLATE!</div>');
+        }, this, 2);
+      })
+      .should('itterate over data if data is an array', function() {
+        var contents = '',
+            app = new Sammy.Application(function() { this.element_selector = '#main'; }),
+            data = [{name: 'one', class_name: 'it-1'}, {name: 'two', class_name: 'it-2'}],
+            expected = '<div class="it-1">one</div><div class="it-2">two</div>';
+                        
+        app.use(Sammy.Template);
+        this.context = new app.context_prototype(app);
+        this.context.partial('fixtures/partial.template', data);
+        this.context.partial('fixtures/partial.template', data, function(html) {
+          contents += html;
+        });
+        soon(function () {
+          equal($('#main').html(), expected);
+          equal(contents, expected);
+        }, this, 2, 2);
+      })
+      .should('cache template if cache() is present', function(){
+        var contents = '';
+        var app = new Sammy.Application(function() { this.element_selector = '#main'; });
+        app.use(Sammy.Template);
+        app.use(Sammy.Cache);
+        app.clearCache();
+        this.context = new app.context_prototype(app);
+        this.context.partial('fixtures/partial.html', function(data) { 
+          contents = data; 
+        });
+        soon(function () {
+          equal(contents, '<div class="test_partial">PARTIAL</div>');
+          equal(app.cache('partial:fixtures/partial.html'), '<div class="test_partial">PARTIAL</div>');
+          this.context.partial('fixtures/partial.html', function(data) { 
+            contents = data;
+          });
+          equal(contents, '<div class="test_partial">PARTIAL</div>');
+        }, this, 1, 3);
+      })
+      .should('not cache template if cache is present and cache_partials: false', function() {
+        var contents = '';
+        var app = new Sammy.Application(function() { this.element_selector = '#main'; });
+        app.use(Sammy.Template);
+        app.use(Sammy.Cache);
+        app.clearCache();
+        app.cache_partials = false;
+        this.context = new app.context_prototype(app);
+        this.context.partial('fixtures/partial.html', function(data) { 
+          contents = data;
+        });
+        soon(function () {
+          equal(contents, '<div class="test_partial">PARTIAL</div>');
+          ok(!app.cache('partial:fixtures/partial.html'));
+        }, this, 1, 2);
+      })
+      .should('replace default app element if no callback is passed', function() {
+        var contents = '';
+        var app = new Sammy.Application(function() { this.element_selector = '#main'; });
+        app.use(Sammy.Template);
+        this.context = new app.context_prototype(app);
+        this.context.partial('fixtures/partial.template', {name: 'TEMPLATE!', class_name: 'test_template'});
+        soon(function () {
+          equal(app.$element().text(), 'TEMPLATE!');
+          equal(app.$element().children('.test_template').length, 1);
+        }, this, 2, 2);
+      })
+      .should('trigger changed after the partial callback', function() {
+        var changed = false;
+        test_app.bind('changed', function() {
+          changed = true;
+        });
+        test_app.run();
+        this.context.partial('fixtures/partial.html', function(data) { 
+          changed = false;
+        });
+        soon(function() {
+          ok(changed);
+          test_app.unload();
+        });
+      })
+      .should('use default engine if provided and template doesnt match an engine', function() {
+        var contents = '';
+        var app = new Sammy.Application(function() { 
+          this.element_selector = '#main'; 
+          this.template_engine  = 'template';
+          
+          this.helper('template',  function(template, data) {
+            return "!!!" + template.toString() + "!!!";
+          });
+        });
+        this.context = new app.context_prototype(app);
+        this.context.partial('fixtures/partial');
+        soon(function () {
+          equal(app.$element().text(), '!!!NOENGINE!!!');
+        });
+      })
+      .should('use default engine as a method if template doesnt match an engine', function() {
+        var contents = '';
+        var app = new Sammy.Application(function() { 
+          this.element_selector = '#main'; 
+          this.template_engine  = function(template, data) {
+            return "!!!" + template.toString() + "!!!";
+          };
+        });
+        this.context = new app.context_prototype(app);
+        this.context.partial('fixtures/partial.noengine');
+        soon(function () {
+          equal(app.$element().text(), '!!!NOENGINE!!!');
+        });
+      });
+      
+      context('Sammy', 'EventContext', 'trigger', {
+        before: function() {
+          this.context = test_context;
+          test_app.run();
+        },
+        after: function() {
+          test_app.unload();
+        }
+      })
+      .should('trigger custom event on application', function() {
+        var spec_context = this;
+        spec_context.event_fired = false;
+        test_app.bind('custom', function() {
+          spec_context.event_fired = true;
+        });
+        this.context.trigger('custom');
+        soon(function() {
+          equal(spec_context.event_fired, true);
+        });
+      })
+      .should('set the context of the event to the Sammy.EventContext', function() {
+        var spec_context = this;
+        var event_context = null;
+        test_app.bind('other.custom', function() {
+          event_context = this;
+        });
+        this.context.trigger('other.custom');
+        soon(function() {
+          equal(event_context.toString(), test_context.toString());
+        });
+      })
+      .should('pass data as an argument to the bound method', function() {
+        var passed_data = null;
+        var test_data   = {boosh: 'blurgh'};
+        test_app.bind('custom-with-data', function(e, data) {
+          passed_data = data;
+        });
+        this.context.trigger('custom-with-data', test_data);
+        soon(function() {
+          deepEqual(passed_data, test_data);
+        });
+      });
+      
+    };
+})(jQuery);

data/test/fixtures/sammy-0.5.0/test/test_sammy_location_proxy.js

@@ -0,0 +1,91 @@
+(function($) {
+  with(QUnit) {
+    
+    context('Sammy', 'HashLocationProxy', {
+      before: function() {
+        this.app = new Sammy.Application;
+        this.proxy = new Sammy.HashLocationProxy(this.app);
+        this.has_native = (typeof window.onhashchange != 'undefined');
+      }
+    })
+    .should('store a pointer to the app', function() {
+      equal(this.proxy.app, this.app)
+    })
+    .should('set is_native true if onhashchange exists in window', function() {
+      if (this.has_native) {
+        var proxy = new Sammy.HashLocationProxy(this.app)
+        ok(proxy.is_native)
+      } else {
+        ok(true, 'No native hash change support.')
+      }
+    })
+    .should('set is_native to false if onhashchange does not exist in window', function() {
+      if (!this.has_native) {
+        var proxy = new Sammy.HashLocationProxy(this.app)
+        ok(!proxy.is_native)
+      } else {
+        ok(true, 'Native hash change support.')
+      }
+    })
+    .should('create poller on hash change', function() {
+      if (!this.has_native) {
+        ok(Sammy.HashLocationProxy._interval);
+        isType(Sammy.HashLocationProxy._interval, 'Number');
+      } else {
+        ok(true, 'Native hash change support.')
+      }
+    })
+    .should('only create a single poller', function() {
+      if (!this.has_native) {
+        var interval = Sammy.HashLocationProxy._interval;
+        var proxy = new Sammy.HashLocationProxy(this.app)
+        equal(Sammy.HashLocationProxy._interval, interval);
+      } else {
+        ok(true, 'Native hash change support.')
+      }
+    });
+
+    
+    context('Sammy', 'DataLocationProxy', {
+      before: function() {
+        this.app = new Sammy.Application(function() {
+          this.location_proxy = new Sammy.DataLocationProxy(this);
+        });
+      }
+    })
+    .should('store a pointer to the app', function() {
+      equal(this.app.location_proxy.app, this.app);
+    })
+    .should('be able to configure data name', function() {
+      var proxy = new Sammy.DataLocationProxy(this.app, 'othername');
+      proxy.setLocation('newlocation');
+      equal($('body').data('othername'), 'newlocation');
+    })
+    .should('trigger app event when data changes', function() {
+      $('body').data(this.app.location_proxy.data_name, '');
+      var triggered = false, app = this.app;
+      app.bind('location-changed', function() {
+        triggered = true;
+      });
+      ok(!triggered);
+      app.run('#/');
+      $('body').data(this.app.location_proxy.data_name, '#/newhash');
+      soon(function() {
+        ok(triggered);
+        equal(this.app.getLocation(), '#/newhash');
+        app.unload();
+      }, this, 2, 3);
+    })
+    .should('return the current location from data', function() {
+      $('body').data(this.app.location_proxy.data_name, '#/zuh')
+      equal(this.app.location_proxy.getLocation(), '#/zuh');
+    })
+    .should('set the current location in data', function() {
+      $('body').data(this.app.location_proxy.data_name, '#/zuh')
+      equal(this.app.location_proxy.getLocation(), '#/zuh');
+      this.app.location_proxy.setLocation('#/boosh');
+      equal('#/boosh', this.app.location_proxy.getLocation());
+    });
+
+  }
+})(jQuery);

data/test/fixtures/sammy-0.5.0/test/test_sammy_plugins.js

@@ -0,0 +1,296 @@
+(function($) {
+    with(QUnit) {
+      context('Sammy.Cache', 'cache', {
+         before: function() {
+           this.app = new Sammy.Application(function() {
+             this.use(Sammy.Cache);
+             this.clearCache();
+             this.cache('mycache', 'my value');
+             this.cache('mynumcache', 3);
+           });
+           this.other_app = new Sammy.Application(function() {
+             this.element_selector = '#main';
+             this.use(Sammy.Cache);
+             this.clearCache();
+             this.cache('mycache', 'not my value');
+             this.cache('mynumcache', 7);
+           });
+         }
+       })
+       .should('retrieve values by passing name', function() {
+         equal(this.app.cache('mycache'), 'my value');
+         equal(this.other_app.cache('mycache'), 'not my value');
+         equal(this.app.cache('mynumcache'), 3);
+         equal(this.other_app.cache('mynumcache'), 7);
+       })
+       .should('set values by passing value', function() {
+         this.app.cache('mycache', 'my new value');
+         equal(this.app.cache('mycache'), 'my new value');
+       })
+       .should('run callback only if value is not set', function() {
+         var inner_context = null;
+         var was_run     = false;
+         this.app.cache('mycache', function() {
+           was_run = true;
+           return 'new value';
+         });
+         equal(was_run, false);
+         equal(inner_context, null);
+         this.app.cache('mynewcache', function() {
+           was_run = true;
+           inner_context = this;
+           return 'new value';
+         });
+         equal(was_run, true);
+         deepEqual(inner_context, this.app.store('cache'), "The inner context should equal the store");
+         equal(this.app.cache('mynewcache'), 'new value', "Should set the new value");
+       })
+       .should('clear specific cache value', function() {
+         this.app.store('cache').clear('mycache');
+         ok(!this.app.cache('mycache'))
+       });
+       
+      
+       context('Sammy', 'Template', {
+         before: function() {
+           this.app = new Sammy.Application(function() {
+             this.use(Sammy.Template);
+           });
+           this.context = new this.app.context_prototype(this.app, 'get', '#/', {});
+           
+           this.alias_app = new Sammy.Application(function() {
+             this.use(Sammy.Template, 'tpl');
+           });
+           this.alias_context = new this.alias_app.context_prototype(this.alias_app, 'get', '#/', {});
+         }
+       })
+       .should('add template helper to event context', function() {
+         ok($.isFunction(this.context.template));
+       })
+       .should('interpolate content', function() {
+         var rendered = this.context.template('<div class="test_class"><%= text %></div>', {text: 'TEXT!'});
+         equal(rendered, '<div class="test_class">TEXT!</div>');
+       })
+       .should('set the context of the template to the test_context', function() {
+         this.context.blurgh = 'boosh';
+         var rendered = this.context.template('<div class="test_class"><%= text %> <%= blurgh %></div>', {text: 'TEXT!'});
+         equal(rendered, '<div class="test_class">TEXT! boosh</div>');
+       })
+       .should('render templates with a lot of single quotes', function() {
+         var rendered = this.context.template("<div class='test_class' id='test'>I'm <%= text %></div>", {text: 'TEXT!'});
+         equal(rendered, "<div class='test_class' id='test'>I'm TEXT!</div>");
+       })
+       .should('alias the template method and thus the extension', function() {
+         ok(!$.isFunction(this.alias_context.template));
+         ok($.isFunction(this.alias_context.tpl));
+         ok(this.alias_context.tpl.toString().match(/srender/));
+       });
+    
+    
+       context('Sammy.NestedParams', 'parsing', {
+         before: function () {
+           this.app = new Sammy.Application(function() {
+             this.element_selector = '#form_params';
+             this.use(Sammy.NestedParams);
+             this.route('post', /test_nested_params/, function() {
+               this.app.form_params = this.params;
+               return false;
+             });
+           });
+         }
+       })
+       .should('parse a twice submitted value', function() {
+         var app = this.app;
+         app.run('#/');
+         $('#nested_params_test_form').submit();
+         soon(function() {
+           ok(app.form_params);
+           equal(app.form_params['author'], 'Thoreau');        
+           app.unload();
+         }, this, 1, 2);
+       })
+       .should('parse basic arrays', function() {
+         var app = this.app;
+         app.run('#/');
+         $('#nested_params_test_form').submit();
+         soon(function() {
+           ok(app.form_params);
+           equal(app.form_params['genre'][0], ['documentary']);
+           equal(app.form_params['genre'][1], ['nature']);
+           app.unload();
+         }, this, 1, 3);
+       })
+       .should('parse basic hashes', function() {
+         var app = this.app;
+         app.run('#/');
+         $('#nested_params_test_form').submit();
+         soon(function() {
+           ok(app.form_params);
+           equal(app.form_params['poll']['name'], 'Which beverage do you like best?');
+           equal(app.form_params['poll']['priority'], '10');
+           app.unload();
+         }, this, 1, 3);      
+       })
+       .should('parse nested hashes', function() {
+         var app = this.app;
+         app.run('#/');
+         $('#nested_params_test_form').submit();
+         soon(function() {
+           ok(app.form_params);
+           equal(app.form_params['poll']['options']['1']['id'], 'Ko5Pi');
+           equal(app.form_params['poll']['options']['1']['name'], 'Coffee');
+           equal(app.form_params['poll']['options']['2']['id'], 'Oaj5N');
+           equal(app.form_params['poll']['options']['2']['name'], 'Tea');
+           app.unload();
+         }, this, 1, 5);
+       })
+       .should('parse arrays in nested hashes', function() {
+         var app = this.app;
+         app.run('#/');
+         $('#nested_params_test_form').submit();
+         soon(function() {
+           ok(app.form_params);
+           equal(app.form_params['poll']['options']['1']['ingredients'][0], 'Water');
+           equal(app.form_params['poll']['options']['1']['ingredients'][1], 'Coffein');
+           app.unload();
+         }, this, 1, 3);
+       })
+       .should('parse hashes in nested arrays in nested hashes', function() {
+         var app = this.app;
+         app.run('#/');
+         $('#nested_params_test_form').submit();
+         soon(function() {
+           ok(app.form_params);
+           equal(app.form_params['woods']['trees'][0]['name'], 'Spruce');
+           equal(app.form_params['woods']['trees'][1]['name'], 'Maple');
+           app.unload();
+         }, this, 1, 3);            
+       })
+       .should('parse arrays in nested hashes in nested arrays', function() {
+         var app = this.app;
+         app.run('#/');
+         $('#nested_params_test_form').submit();
+         soon(function() {
+           ok(app.form_params);
+           equal(app.form_params['pages'][0]['words'][0], 'Woods');
+           equal(app.form_params['pages'][1]['words'][0], 'Money');
+           app.unload();
+         }, this, 1, 3);      
+       })
+       .should('parse complex hashes in nested arrays in nested hashes', function() {
+         var app = this.app;
+         app.run('#/');
+         $('#nested_params_test_form').submit();
+         soon(function() {
+           ok(app.form_params);
+           equal(app.form_params['music']['instruments'][0]['name'], 'Piano');
+           equal(app.form_params['music']['instruments'][0]['size'], 'big');
+           equal(app.form_params['music']['instruments'][1]['name'], 'Flute');
+           equal(app.form_params['music']['instruments'][1]['size'], 'small');
+           app.unload();
+         }, this, 1, 5);
+       })
+       .should('unescape escaped params', function() {
+         var app = this.app;
+         app.run('#/');
+         $('#nested_params_test_form').submit();
+         soon(function() {
+           ok(app.form_params);
+           equal(app.form_params['title'], 'Walden!');
+           app.unload();
+         }, this, 1, 2);
+       });
+       
+       context('Sammy.NestedParams', 'bad fields', {
+         before: function () {
+           this.app = new Sammy.Application(function() {
+             this.element_selector = '#form_params';
+             this.use(Sammy.NestedParams);
+           });
+         }
+       }).should('raise error for bad params', function() {
+         var app = this.app;
+         raised(/400/, function() {
+           app._parseFormParams($('#bad_nested_params_form'));
+         });
+       });
+       
+       
+       // Pretty much a copy of the Template tests
+       context('Sammy', 'Mustache', {
+          before: function() {
+            this.app = new Sammy.Application(function() {
+              this.use(Sammy.Mustache);
+            });
+            this.context = new this.app.context_prototype(this.app, 'get', '#/', {});
+
+            this.alias_app = new Sammy.Application(function() {
+              this.use(Sammy.Mustache, 'ms');
+            });
+            this.alias_context = new this.alias_app.context_prototype(this.alias_app, 'get', '#/', {});
+          }
+        })
+        .should('add mustache helper to event context', function() {
+          ok($.isFunction(this.context.mustache));
+        })
+        .should('interpolate content', function() {
+          var rendered = this.context.mustache('<div class="test_class">{{text}}</div>', {text: 'TEXT!'});
+          equal(rendered, '<div class="test_class">TEXT!</div>');
+        })
+        .should('set the context of the template to the test_context', function() {
+          this.context.blurgh = 'boosh';
+          var rendered = this.context.mustache('<div class="test_class">{{text}} {{blurgh}}</div>', {text: 'TEXT!'});
+          equal(rendered, '<div class="test_class">TEXT! boosh</div>');
+        })
+        .should('allow mustache partials by passing partials to data', function() {
+          var data = {blurgh: 'boosh', partials: {first: 'a {{what}}'}, first: {what: 'partial'}};
+          var rendered = this.context.mustache('<div class="test_class">{{>first}} {{blurgh}}</div>', data);
+          equal(rendered, '<div class="test_class">a partial boosh</div>');
+        })
+        .should('alias the mustache method and thus the extension', function() {
+          ok(!$.isFunction(this.alias_context.mustache));
+          ok($.isFunction(this.alias_context.ms));
+          ok(this.alias_context.ms.toString().match(/Mustache/));
+        });
+      
+      context('Sammy', 'JSON', {
+        before: function() {
+          this.app = new Sammy.Application(function() {
+            this.use(Sammy.JSON);
+          });
+          this.context = new this.app.context_prototype(this.app, 'get', '#/', {});
+        }
+      })
+      .should('add json helper to event context', function() {
+        ok($.isFunction(this.context.json));
+      })
+      .should('ensure JSON is in the global namespace', function() {
+        ok($.isFunction(JSON.parse));
+        ok($.isFunction(JSON.stringify));
+      })
+      .should('parse JSON if object is a string', function() {
+        equal(this.context.json("{\"test\":\"123\"}").test, "123");
+      })
+      .should('stringify JSON if object is an object', function() {
+        equal(this.context.json({test: "123"}),"{\"test\":\"123\"}");
+      });
+      
+      
+      context('Sammy', 'Haml', {
+        before: function() {
+          this.app = new Sammy.Application(function() {
+            this.use(Sammy.Haml);
+          });
+          this.context = new this.app.context_prototype(this.app, 'get', '#/', {});
+        }
+      })
+      .should('add haml helper to context', function() {
+        ok($.isFunction(this.context.haml));
+      })
+      .should('use haml-js to render haml templates', function() {
+        var template = ".mytemplate= title";
+        deepEqual(this.context.haml(template, {title: "HAML!!"}), "<div class=\"mytemplate\">HAML!!\n</div>");
+      });
+      
+    };
+})(jQuery);