joosy 0.1.0.alpha → 1.0.0.RC1

data/spec/javascripts/joosy/core/router_spec.js.coffee

@@ -0,0 +1,143 @@
+describe "Joosy.Router", ->
+
+  class TestPage extends Joosy.Page
+
+  spies =
+    root: sinon.spy()
+    section: sinon.spy()
+    wildcard: sinon.spy()
+
+  map = Object.extended
+    '/': spies.root
+    '/page': TestPage
+    '/section':
+      '/page/:id': spies.section
+      '/page2/:more': TestPage
+    404: spies.wildcard
+
+  beforeEach ->
+    Joosy.Router.reset()
+
+  afterEach ->
+    $(window).unbind 'hashchange'
+
+  it "should map", ->
+    Joosy.Router.map map
+    expect(Joosy.Router.rawRoutes).toEqual map
+
+  it "should initialize on setup", ->
+    sinon.stub Joosy.Router, '__prepareRoutes'
+    sinon.stub Joosy.Router, '__respondRoute'
+
+    Joosy.Router.map map
+    Joosy.Router.__setupRoutes()
+    expect(Joosy.Router.__prepareRoutes.callCount).toEqual 1
+    expect(Joosy.Router.__prepareRoutes.args[0][0]).toEqual map
+    expect(Joosy.Router.__respondRoute.callCount).toEqual 1
+    expect(Joosy.Router.__respondRoute.args[0][0]).toEqual location.hash
+    Joosy.Router.__prepareRoutes.restore()
+    Joosy.Router.__respondRoute.restore()
+
+  it "should prepare route", ->
+    route = Joosy.Router.__prepareRoute "/such/a/long/long/url/:with/:plenty/:of/:params", "123"
+
+    expect(route).toEqual Object.extended
+      '^/?such/a/long/long/url/([^/]+)/([^/]+)/([^/]+)/([^/]+)/?$':
+        capture: ['with', 'plenty', 'of', 'params']
+        action: "123"
+
+  it "should cook routes", ->
+    sinon.stub Joosy.Router, '__respondRoute'
+
+    Joosy.Router.map map
+    Joosy.Router.__setupRoutes()
+
+    expect(Joosy.Router.routes).toEqual Object.extended
+      '^/?/?$':
+        capture: []
+        action: spies.root
+      '^/?page/?$':
+        capture: []
+        action: TestPage
+      '^/?section/page/([^/]+)/?$':
+        capture: ['id']
+        action: spies.section
+      '^/?section/page2/([^/]+)/?$':
+        capture: ['more']
+        action: TestPage
+
+    Joosy.Router.__respondRoute.restore()
+
+  it "should get route params", ->
+    route  = Joosy.Router.__prepareRoute "/such/a/long/long/url/:with/:plenty/:of/:params", "123"
+    result = Joosy.Router.__paramsFromRouteMatch ['full regex match here', 1, 2, 3, 4], route.values().first()
+
+    expect(result).toEqual Object.extended
+      'with':   1
+      'plenty': 2
+      'of':     3
+      'params': 4
+
+  it "should build query params", ->
+    result = Joosy.Router.__paramsFromQueryArray ["foo=bar", "bar=baz"]
+
+    expect(result).toEqual Object.extended
+      foo: 'bar'
+      bar: 'baz'
+
+  it "should respond routes", ->
+    sinon.stub Joosy.Router, '__respondRoute'
+    sinon.stub Joosy.Application, 'setCurrentPage'
+
+    Joosy.Router.map map
+    Joosy.Router.__setupRoutes()
+
+    Joosy.Router.__respondRoute.restore()
+
+    Joosy.Router.__respondRoute '/'
+    expect(spies.root.callCount).toEqual 1
+
+    Joosy.Router.__respondRoute '/page'
+    expect(Joosy.Application.setCurrentPage.callCount).toEqual 1
+    expect(Joosy.Application.setCurrentPage.args.last()).toEqual [TestPage, Object.extended()]
+
+    Joosy.Router.__respondRoute '/section/page/1'
+    expect(spies.section.callCount).toEqual 1
+    expect(spies.section.args.last()).toEqual [Object.extended(id: '1')]
+
+    Joosy.Router.__respondRoute '/section/page2/1&a=b'
+    expect(Joosy.Application.setCurrentPage.callCount).toEqual 2
+    expect(Joosy.Application.setCurrentPage.args.last()).toEqual [TestPage, Object.extended(more: '1', a: 'b')]
+
+    Joosy.Router.__respondRoute '/thiswillneverbefound&a=b'
+    expect(spies.wildcard.callCount).toEqual 1
+    expect(spies.wildcard.args.last()).toEqual ['/thiswillneverbefound', Object.extended(a: 'b')]
+
+    Joosy.Application.setCurrentPage.restore()
+
+  it "should navigate", ->
+    Joosy.Router.navigate 'test'
+    expect(location.hash).toEqual '#!test'
+    Joosy.Router.navigate ''
+    expect(location.hash).toEqual '#!'
+    location.hash = ''
+
+  it "should restrict urls", ->
+    sinon.stub Joosy.Router, '__respondRoute'
+    sinon.stub Joosy.Application, 'setCurrentPage'
+
+    Joosy.Router.map map
+    Joosy.Router.__setupRoutes()
+
+    Joosy.Router.__respondRoute.restore()
+
+    Joosy.Router.restrict /^\/page$/
+
+    Joosy.Router.__respondRoute '/page'
+    Joosy.Router.__respondRoute '/section/page/1'
+
+    expect(Joosy.Application.setCurrentPage.callCount).toEqual 1
+    expect(Joosy.Application.setCurrentPage.args.last()).toEqual [TestPage, Object.extended()]
+
+    Joosy.Application.setCurrentPage.restore()
+    Joosy.Router.restrict false

data/spec/javascripts/joosy/core/templaters/rails_jst_spec.js.coffee

@@ -0,0 +1,25 @@
+describe "Joosy.Templaters.RailsJST", ->
+
+  beforeEach ->
+    @templater = new Joosy.Templaters.RailsJST()
+
+    class @Klass extends Joosy.Module
+
+    Joosy.namespace 'British.Cities', ->
+      class @Klass extends Joosy.Module
+
+  it "should resolve templates correctly", ->
+    expect(@templater.resolveTemplate(undefined, "/absolute", undefined)).
+        toEqual "absolute"
+
+    expect(@templater.resolveTemplate('widgets', 'fuga', {})).
+        toEqual 'widgets/fuga'
+
+    expect(@templater.resolveTemplate('widgets', 'fuga', new @Klass)).
+        toEqual 'widgets/fuga'
+
+    expect(@templater.resolveTemplate('widgets', 'fuga', new British.Cities.Klass)).
+        toEqual 'widgets/british/cities/fuga'
+
+    expect(@templater.resolveTemplate('widgets', 'hoge/fuga', new British.Cities.Klass)).
+        toEqual 'widgets/british/cities/hoge/fuga'

data/spec/javascripts/joosy/core/widget_spec.js.coffee

@@ -0,0 +1,40 @@
+describe "Joosy.Widget", ->
+
+  beforeEach ->
+    class @TestWidget extends Joosy.Widget
+    @box = new @TestWidget()
+
+  it "should have appropriate accessors", ->
+    test = ->
+    @TestWidget.view test
+    expect(@TestWidget::__renderer).toEqual test
+    @TestWidget.view 'test'
+    expect(@TestWidget::__renderer instanceof Function).toBeTruthy()
+
+  it "should use Router", ->
+    target = sinon.stub Joosy.Router, 'navigate'
+    @box.navigate 'there'
+    expect(target.callCount).toEqual 1
+    expect(target.alwaysCalledWithExactly 'there').toBeTruthy()
+    Joosy.Router.navigate.restore()
+
+  it "should load itself", ->
+    @box.data = {tested: true}
+    spies = [sinon.spy()]
+    @TestWidget.view spies[0]
+    @parent = new Joosy.Layout()
+    spies.push sinon.spy(@box, 'refreshElements')
+    spies.push sinon.spy(@box, '__delegateEvents')
+    spies.push sinon.spy(@box, '__runAfterLoads')
+    target = @box.__load @parent, @ground
+    expect(target).toBe @box
+    expect(@box.__renderer.getCall(0).calledOn()).toBeFalsy()
+    expect(@box.__renderer.getCall(0).args[0]).toEqual {tested: true}
+    expect(spies).toBeSequenced()
+
+  it "should unload itself", ->
+    sinon.spy @box, '__runAfterUnloads'
+    @box.__unload()
+    target = @box.__runAfterUnloads
+    expect(target.callCount).toEqual 1
+    expect(target.getCall(0).calledOn()).toBeFalsy()

data/spec/javascripts/joosy/preloaders/caching_spec.js.coffee

@@ -0,0 +1,36 @@
+describe "CachingPreloader", ->
+
+  it "should load JS", ->
+    window.variable_assigned_on_load = undefined
+    localStorage.clear()
+    
+    callback = sinon.spy()
+    server   = sinon.fakeServer.create()
+    
+    load = ->
+      CachingPreloader.load [['/spec/javascripts/support/assets/test.js']], 
+        complete: callback
+
+    load()
+    
+    expect(server.requests.length).toEqual 1
+    target = server.requests[0]
+    expect(target.method).toEqual 'GET'
+    expect(target.url).toMatch /^\/spec\/javascripts\/support\/assets\/test.js$/
+    target.respond 200, 'Content-Type': 'application/javascript',
+      "window.variable_assigned_on_load = 'yapyap';"
+
+    expect(callback.callCount).toEqual 1
+    expect(window.variable_assigned_on_load).toEqual 'yapyap'
+    window.variable_assigned_on_load = undefined
+    
+    load()
+    
+    expect(server.requests.length).toEqual 1
+    expect(callback.callCount).toEqual 2
+    expect(window.variable_assigned_on_load).toEqual 'yapyap'
+
+    server.restore()
+
+    window.variable_assigned_on_load = undefined
+    localStorage.clear()

data/spec/javascripts/joosy/preloaders/inline_spec.js.coffee

@@ -0,0 +1,16 @@
+describe "InlinePreloader", ->
+
+  it "should load JS", ->
+    window.variable_assigned_on_load = undefined
+    callback = sinon.spy()
+    
+    runs ->
+      InlinePreloader.load [['/spec/javascripts/support/assets/test.js']], 
+        complete: callback
+    
+    waits 100
+    
+    runs ->
+      expect(callback.callCount).toEqual 1
+      expect(window.variable_assigned_on_load).toEqual 'yapyap'
+      window.variable_assigned_on_load = undefined

data/spec/javascripts/support/assets/test.js

@@ -0,0 +1 @@
+window.variable_assigned_on_load = 'yapyap';

data/spec/javascripts/support/sinon-ie-1.3.1.js

@@ -0,0 +1,82 @@
+/**
+ * Sinon.JS 1.3.1, 2012/01/04
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ *
+ * (The BSD License)
+ * 
+ * Copyright (c) 2010-2011, Christian Johansen, christian@cjohansen.no
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright notice,
+ *       this list of conditions and the following disclaimer in the documentation
+ *       and/or other materials provided with the distribution.
+ *     * Neither the name of Christian Johansen nor the names of his contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+"use strict";
+/*global sinon, setTimeout, setInterval, clearTimeout, clearInterval, Date*/
+/**
+ * Helps IE run the fake timers. By defining global functions, IE allows
+ * them to be overwritten at a later point. If these are not defined like
+ * this, overwriting them will result in anything from an exception to browser
+ * crash.
+ *
+ * If you don't require fake timers to work in IE, don't include this file.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+function setTimeout() {}
+function clearTimeout() {}
+function setInterval() {}
+function clearInterval() {}
+function Date() {}
+
+// Reassign the original functions. Now their writable attribute
+// should be true. Hackish, I know, but it works.
+setTimeout = sinon.timers.setTimeout;
+clearTimeout = sinon.timers.clearTimeout;
+setInterval = sinon.timers.setInterval;
+clearInterval = sinon.timers.clearInterval;
+Date = sinon.timers.Date;
+
+/*global sinon*/
+/**
+ * Helps IE run the fake XMLHttpRequest. By defining global functions, IE allows
+ * them to be overwritten at a later point. If these are not defined like
+ * this, overwriting them will result in anything from an exception to browser
+ * crash.
+ *
+ * If you don't require fake XHR to work in IE, don't include this file.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+function XMLHttpRequest() {}
+
+// Reassign the original function. Now its writable attribute
+// should be true. Hackish, I know, but it works.
+XMLHttpRequest = sinon.xhr.XMLHttpRequest || undefined;