joosy 0.1.0.RC1

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

@@ -0,0 +1,72 @@
+describe "Joosy", ->
+
+  it "should properly initialize", ->
+    expect(Joosy.debug).toBeFalsy()
+    expect(Joosy.Modules).toBeDefined()
+    expect(Joosy.Resource).toBeDefined()
+
+  it "should declare namespaces", ->
+    Joosy.namespace 'Namespaces.Test1'
+    Joosy.namespace 'Namespaces.Test2', ->
+      @bingo = 'bongo'
+    expect(window.Namespaces.Test1).toBeDefined()
+    expect(window.Namespaces.Test2.bingo).toEqual('bongo')
+
+  it "should imprint namespace paths in Joosy.Module descendants", ->
+    Joosy.namespace 'Irish', ->
+      class @Pub extends Joosy.Module
+
+    Joosy.namespace 'British', ->
+      class @Pub extends Joosy.Module
+
+    Joosy.namespace 'Keltic', ->
+      class @Pub extends Irish.Pub
+
+    expect(Irish.Pub.__namespace__).toEqual ["Irish"]
+    expect(British.Pub.__namespace__).toEqual ["British"]
+    expect(Keltic.Pub.__namespace__).toEqual ["Keltic"]
+
+    Joosy.namespace 'Deeply.Nested', ->
+      class @Klass extends Joosy.Module
+
+    expect(Deeply.Nested.Klass.__namespace__).toEqual ["Deeply", "Nested"]
+
+    class @Flat extends Joosy.Module
+
+    expect(@Flat.__namespace__).toEqual []
+
+  it "should set up helpers", ->
+    Joosy.helpers 'Hoge', ->
+      @fuga = ->
+        "piyo"
+
+    expect(window.Joosy.Helpers).toBeDefined()
+    expect(window.Joosy.Helpers.Hoge).toBeDefined()
+    expect(window.Joosy.Helpers.Hoge.fuga()).toBe "piyo"
+
+  it "should generate proper UUIDs", ->
+    uuids = []
+    2.times ->
+      uuids.push Joosy.uuid()
+    expect(uuids.unique().length).toEqual(2)
+    expect(uuids[0]).toMatch /[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}/
+
+  it "should build proper URLs", ->
+    expect(Joosy.buildUrl 'http://www.org').toEqual('http://www.org')
+    expect(Joosy.buildUrl 'http://www.org#hash').toEqual('http://www.org#hash')
+    expect(Joosy.buildUrl 'http://www.org', {foo: 'bar'}).toEqual('http://www.org?foo=bar')
+    expect(Joosy.buildUrl 'http://www.org?bar=baz', {foo: 'bar'}).toEqual('http://www.org?bar=baz&foo=bar')
+
+  it "should preload images", ->
+    path   = "/spec/javascripts/support/assets/"
+    images = [path+"okay.jpg", path+"okay.jpg"]
+
+    callback = sinon.spy()
+
+    runs -> Joosy.preloadImages path+"coolface.jpg", callback
+    waits(150)
+    runs -> expect(callback.callCount).toEqual(1)
+
+    runs -> Joosy.preloadImages images, callback
+    waits(150)
+    runs -> expect(callback.callCount).toEqual(2)

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

@@ -0,0 +1,50 @@
+describe "Joosy.Layout", ->
+
+  beforeEach ->
+    class @TestLayout extends Joosy.Layout
+    @box = new @TestLayout()
+
+  it "should have appropriate accessors", ->
+    callback_names = ['beforePaint', 'paint', 'erase']
+    callback_names.each (func) =>
+      @TestLayout[func] 'callback'
+      expect(@TestLayout::['__' + func]).toEqual 'callback'
+
+  it "should have default view", ->
+    @box = new @TestLayout()
+    expect(@box.__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", ->
+    spies = []
+    spies.push sinon.spy(@box, 'refreshElements')
+    spies.push sinon.spy(@box, '__delegateEvents')
+    spies.push sinon.spy(@box, '__setupWidgets')
+    spies.push sinon.spy(@box, '__runAfterLoads')
+    @box.__load(@ground)
+    expect(spies).toBeSequenced()
+
+  it "should unload itself", ->
+    spies = []
+    spies.push sinon.spy(@box, 'clearTime')
+    spies.push sinon.spy(@box, '__unloadWidgets')
+    spies.push sinon.spy(@box, '__runAfterUnloads')
+    @box.__unload()
+    expect(spies).toBeSequenced()
+
+  it "should generate uuid", ->
+    sinon.spy Joosy, 'uuid'
+    @box.yield()
+    expect(Joosy.uuid.callCount).toEqual 1
+    expect(@box.uuid).toBeDefined()
+    Joosy.uuid.restore()
+
+  it "should uuid as selector", ->
+    @box.yield()
+    expect(@box.content().selector).toEqual '#' + @box.uuid

data/spec/javascripts/joosy/core/modules/container_spec.js.coffee

@@ -0,0 +1,92 @@
+describe "Joosy.Modules.Container", ->
+
+  beforeEach ->
+    @seedGround()
+    class @TestContainer extends Joosy.Module
+      @include Joosy.Modules.Container
+      elements:
+        footer: '.footer'
+      events:
+        'test': 'onContainerTest'
+      container: $('#application', @ground)
+    @box = new @TestContainer()
+
+
+  it "should have property named per declared element in container", ->
+    @ground.prepend('<div class="footer" />')  # out of container
+    @box.refreshElements()
+    target = @box.footer.get 0
+    expect(target).toBeTruthy()
+    expect(target).toBe $('.footer', @box.container).get 0
+    expect(target).toBe @box.$('.footer').get 0
+
+  it "should reinitialize container", ->
+    old_container = @box.container
+    parent = old_container.parent()
+    callback = sinon.spy()
+    old_container.bind 'test', callback
+    old_container.trigger 'test'
+    new_container = Joosy.Modules.Container.swapContainer old_container, 'new content'
+    new_container.trigger 'test'
+    expect(new_container.html()).toEqual 'new content'
+    expect(new_container.parent().get(0)).toBe parent.get 0
+    expect(old_container.parent().get(0)).toBeUndefined()
+    expect(callback.callCount).toEqual 1
+
+  it "should inherit element declarations", ->
+    class SubContainerA extends @TestContainer
+      elements:
+        first: 'first'
+        second: 'second'
+    class SubContainerB extends SubContainerA
+      elements:
+        first: 'overrided'
+        third: 'third'
+    subBox = new SubContainerB()
+    target = subBox.__collectElements()
+    expect(target).toEqual Object.extended
+      first: 'overrided'
+      second: 'second'
+      third: 'third'
+      footer: '.footer'
+    target = (new @TestContainer()).__collectElements()
+    expect(target).toEqual Object.extended(footer: '.footer')
+
+  it "should resolve element selector", ->
+    target = @box.__extractSelector '$footer'
+    expect(target).toEqual '.footer'
+
+  it "should inherit event declarations", ->
+    class SubContainerA extends @TestContainer
+      events:
+        'test .post': 'callback2'
+        'custom' : 'method'
+    class SubContainerB extends SubContainerA
+      events:
+        'test $footer': 'onFooterTest'
+        'custom' : 'overrided'
+    subBox = new SubContainerB()
+    target = subBox.__collectEvents()
+    expect(target).toEqual Object.extended
+      'test': 'onContainerTest'
+      'test .post': 'callback2'
+      'test $footer': 'onFooterTest'
+      'custom' : 'overrided'
+    target = (new @TestContainer()).__collectEvents()
+    expect(target).toEqual Object.extended('test': 'onContainerTest')
+
+  it "should delegate events", ->
+    callback = 1.upto(3).map -> sinon.spy()
+    @box.events = Object.extended(@box.events).merge
+      'test .post': callback[2]
+      'test $footer': 'onFooterTest'
+
+    @box.onContainerTest = callback[0]
+    @box.onFooterTest = callback[1]
+    @box.__delegateEvents()
+    @box.container.trigger 'test'
+    $('.footer', @box.container).trigger 'test'
+    $('.post', @box.container).trigger 'test'
+    expect(callback[0].callCount).toEqual 5
+    expect(callback[1].callCount).toEqual 1
+    expect(callback[2].callCount).toEqual 3

data/spec/javascripts/joosy/core/modules/events_spec.js.coffee

@@ -0,0 +1,53 @@
+describe "Joosy.Modules.Events", ->
+
+  beforeEach ->
+    class @TestEvents extends Joosy.Module
+      @include Joosy.Modules.Events
+    class @SubTestEvents extends @TestEvents
+      @include Joosy.Modules.Events
+    @box = new @TestEvents()
+    @sub = new @SubTestEvents()
+
+  it "should run callback once when the all listed events have occurred", ->
+    callback = sinon.spy()
+
+    @box.wait 'events   list', callback
+
+    @box.trigger 'events'
+    expect(callback.callCount).toEqual 0
+    @box.trigger 'list'
+    expect(callback.callCount).toEqual 1
+
+    @box.trigger 'events'
+    expect(callback.callCount).toEqual 1
+    @box.trigger 'list'
+    expect(callback.callCount).toEqual 1
+
+  it "should allow for binding and unbinding to events", ->
+    callback = sinon.spy()
+
+    @box.bind 'event', callback
+
+    @box.trigger 'other-event'
+    expect(callback.callCount).toEqual 0
+    @box.trigger 'event'
+    expect(callback.callCount).toEqual 1
+    @box.trigger 'event'
+    expect(callback.callCount).toEqual 2
+
+    @box.unbind 'other-event'
+
+    @box.trigger 'event'
+    expect(callback.callCount).toEqual 3
+
+    @box.unbind callback
+
+    @box.trigger 'event'
+    expect(callback.callCount).toEqual 3
+
+  it "should handle inheritance well", ->
+    callback = sinon.spy()
+    @sub.wait 'foo', callback
+
+    expect(@sub.__oneShotEvents).toEqual [[['foo'], callback]]
+    expect(@box.__oneShotEvents).toBeUndefined()

data/spec/javascripts/joosy/core/modules/filters_spec.js.coffee

@@ -0,0 +1,71 @@
+describe "Joosy.Modules.Filters", ->
+
+  beforeEach ->
+    class @TestFilters extends Joosy.Module
+      @include Joosy.Modules.Filters
+    @box = new @TestFilters()
+
+
+  it "should inherit filters by copying them", ->
+    class SubFiltersA extends @TestFilters
+      @beforeLoad 'filter1'
+      @afterLoad 'filter2'
+      @afterUnload 'filter3'
+    class SubFiltersB extends SubFiltersA
+      @beforeLoad 'filter4'
+      @afterLoad 'filter5'
+      @afterUnload 'filter6'
+    target = new SubFiltersB()
+    expect(target.__beforeLoads).toEqual ['filter1', 'filter4']
+    expect(target.__afterLoads).toEqual ['filter2', 'filter5']
+    expect(target.__afterUnloads).toEqual ['filter3', 'filter6']
+    target = new SubFiltersA()
+    expect(target.__beforeLoads).toEqual ['filter1']
+    expect(target.__afterLoads).toEqual ['filter2']
+    expect(target.__afterUnloads).toEqual ['filter3']
+    target = new @TestFilters()
+    expect(target.__beforeLoads).toBeUndefined()
+    expect(target.__afterLoads).toBeUndefined()
+    expect(target.__afterUnloads).toBeUndefined()
+
+  it "should run callbacks", ->
+    callback = 0.upto(2).map -> sinon.spy()
+    @box.constructor.beforeLoad callback[0]
+    @box.constructor.afterLoad callback[1]
+    @box.constructor.afterUnload callback[2]
+    @box.__runBeforeLoads 1, 2
+    @box.__runAfterLoads 1, 2
+    @box.__runAfterUnloads 1, 2
+    for i in 0.upto(2)
+      expect(callback[i].callCount).toEqual 1
+      expect(callback[i].alwaysCalledWithExactly 1, 2).toBeTruthy()
+
+  it "should chain beforeLoad filters", ->
+    callback = 0.upto(2).map -> sinon.stub()
+    callback[0].returns true
+    @box.constructor.beforeLoad(callback[i]) for i in 0.upto 2
+    expect(@box.__runBeforeLoads()).toBeFalsy()
+    expect(callback[0].callCount).toEqual 1
+    expect(callback[1].callCount).toEqual 1
+    expect(callback[2].callCount).toEqual 0
+
+  it "should chain beforeLoad filters", ->
+    callback = 0.upto(1).map -> sinon.stub()
+    callback[0].returns true
+    callback[1].returns true
+    @box.constructor.beforeLoad(callback[i]) for i in 0.upto(1)
+    expect(@box.__runBeforeLoads()).toBeTruthy()
+    expect(callback[0].callCount).toEqual 1
+    expect(callback[1].callCount).toEqual 1
+
+  it "should accept callback names", ->
+    @box.constructor.beforeLoad 'callback0'
+    @box.constructor.afterLoad 'callback1'
+    @box.constructor.afterUnload 'callback2'
+    for i in 0.upto(2)
+      @box['callback' + i] = sinon.spy()
+    @box.__runBeforeLoads()
+    @box.__runAfterLoads()
+    @box.__runAfterUnloads()
+    for i in 0.upto(2)
+      expect(@box['callback' + i].callCount).toEqual 1

data/spec/javascripts/joosy/core/modules/log_spec.js.coffee

@@ -0,0 +1,15 @@
+describe "Joosy.Modules.Log", ->
+
+  beforeEach ->
+    class @TestLog extends Joosy.Module
+      @include Joosy.Modules.Log
+    @box = new @TestLog()
+
+  it "should log into console", ->
+    @box.log 'message', 'appendix'
+
+  it "should log debug messages into console", ->
+    Joosy.debug = true
+    @box.debug 'debug message'
+    Joosy.debug = false
+    @box.debug 'unseen debug message'

data/spec/javascripts/joosy/core/modules/module_spec.js.coffee

@@ -0,0 +1,47 @@
+describe "Joosy.Module", ->
+
+  it "should track inheritance", ->
+    class A
+    class B extends A
+    class C extends B
+    class D
+    for a in [A, B, C, D]
+      for b in [A, B, C, D]
+        if (a == b) ||
+          ((a == B) && (b == A)) ||
+          ((a == C) && (b != D))
+            expect(Joosy.Module.hasAncestor.apply(null, [a, b])).toBeTruthy()
+        else
+          expect(Joosy.Module.hasAncestor.apply(null, [a, b])).toBeFalsy()
+
+  it "should include properties into prototype", ->
+    TestModule =
+      property: 'value'
+    class Klass extends Joosy.Module
+      @include TestModule
+    expect(Klass::property).toEqual 'value'
+    expect((new Klass()).property).toEqual 'value'
+
+  it "should extend object", ->
+    TestModule =
+      property: 'value'
+    class Klass extends Joosy.Module
+      @extend TestModule
+    expect(Klass.property).toEqual 'value'
+    expect((new Klass()).property).toBeUndefined()
+
+  it "should run callbacks on include and extend", ->
+    TestModule =
+      property: 'value'
+      included: sinon.spy()
+      extended: sinon.spy()
+    class Klass extends Joosy.Module
+      @include TestModule
+      @extend TestModule
+    for callback in ['included', 'extended']
+      expect(TestModule[callback].callCount).toEqual 1
+      expect(TestModule[callback].getCall(0).calledOn(Klass)).toBeTruthy()
+
+  it "should have minimal set of properties", ->
+    expect(Object.extended(Joosy.Module).keys()).toEqual ['__namespace__', '__className__', 'hasAncestor', 'include', 'extend']
+    expect(Object.extended(Joosy.Module.prototype).keys()).toEqual []

data/spec/javascripts/joosy/core/modules/renderer_spec.js.coffee

@@ -0,0 +1,149 @@
+describe "Joosy.Modules.Renderer", ->
+
+  beforeEach ->
+    @seedGround()
+
+    class @TestContainer extends Joosy.Module
+      @include Joosy.Modules.Renderer
+
+    @dummyContainer = new @TestContainer
+
+    class @TestObject extends Joosy.Module
+      @include Joosy.Modules.Events
+
+      constructor: (@value) ->
+
+      update: (@value) ->
+        @trigger 'changed'
+
+    @dummyObject = new @TestObject("initial")
+
+    Joosy.namespace 'Joosy.Helpers.Hoge', ->
+      @multiplier = (value) ->
+        "#{value * 5}"
+
+  it "should update contents, but only while it is bound to DOM", ->
+    @TestContainer.view (locals) ->
+      template = (locals) ->
+        "#{locals.object.value}"
+
+      @render(template, locals)
+
+    elem = $("<div></div>")
+    @ground.append elem
+
+    elem.html @dummyContainer.__renderer({ object: @dummyObject })
+    expect(elem.text()).toBe "initial"
+
+    @dummyObject.update "new"
+
+    waits 0
+      
+    runs ->
+      expect(elem.text()).toBe "new"
+    
+    waits 0
+    
+    runs ->
+      @dummyContainer.__removeMetamorphs()
+      @dummyObject.update "afterwards"
+    
+    waits 0
+    
+    runs ->
+      expect(elem.text()).toBe "new"
+    
+  it "should render resources and keep html up2date", ->
+    data = Joosy.Resource.Generic.create zombie: 'rock'
+
+    @TestContainer.view (locals) ->
+      template = (locals) -> 
+        "#{locals.zombie}"
+
+      @render(template, locals)
+
+    elem = $("<div></div>")
+    @ground.append elem
+  
+    elem.html @dummyContainer.__renderer(data)
+    
+    waits 0
+
+    runs -> 
+      expect(elem.text()).toBe "rock"
+    
+    runs ->
+      data 'zombie', 'suck'
+    
+    waits 0 
+
+    runs ->
+      expect(elem.text()).toBe "suck"
+
+  it "should debounce morpher updates", ->
+    @TestContainer.view (locals) ->
+      template = (locals) ->
+        "#{locals.object.value}"
+  
+      @render(template, locals)
+  
+    elem = $("<div></div>")
+    @ground.append elem
+    
+    sinon.spy window, 'Metamorph'
+  
+    elem.html @dummyContainer.__renderer({ object: @dummyObject })
+    expect(elem.text()).toBe "initial"
+    
+    updater = sinon.spy window.Metamorph.returnValues[0], 'html'
+  
+    @dummyObject.update "new"
+    
+    waits 0
+    
+    runs ->
+      expect(elem.text()).toBe "new"
+      expect(updater.callCount).toEqual 1
+      
+    runs ->
+      @dummyObject.update "don't make"
+      @dummyObject.update "me evil"
+    
+    waits 0
+    
+    runs ->
+      expect(elem.text()).toBe "me evil"
+      expect(updater.callCount).toEqual 2
+
+  it "should include rendering helpers in locals", ->
+    @TestContainer.helpers "Hoge"
+
+    @TestContainer.view (locals) ->
+      template = (locals) ->
+        "#{locals.multiplier(10)}"
+
+      @render(template, locals)
+
+    elem = $("<div></div>")
+    @ground.append elem
+
+    elem.html @dummyContainer.__renderer({ })
+
+    expect(elem.text()).toBe "50"
+
+  it "should include global rendering helpers in locals", ->
+    Joosy.Helpers.Application.globalMultiplier = (value) ->
+      value * 6
+
+    @TestContainer.view (locals) ->
+      template = (locals) ->
+        "#{locals.globalMultiplier(10)}"
+
+      @render(template, locals)
+
+    elem = $("<div></div>")
+    @ground.append elem
+
+    elem.html @dummyContainer.__renderer({ })
+
+    expect(elem.text()).toBe "60"