joosy 0.1.0.alpha → 1.0.0.RC1

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

@@ -15,23 +15,22 @@ describe "Joosy.Modules.Container", ->
   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)
+    target = @box.footer.get 0
     expect(target).toBeTruthy()
-    expect(target).toBe($('.footer', @box.container).get(0))
-    expect(target).toBe(@box.$('.footer').get(0))
+    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)
+    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(callback.callCount).toEqual 1
 
   it "should inherit element declarations", ->
     class SubContainerA extends @TestContainer
@@ -44,18 +43,17 @@ describe "Joosy.Modules.Container", ->
         third: 'third'
     subBox = new SubContainerB()
     target = subBox.__collectElements()
-    expect(target).toEqual(
+    expect(target).toEqual Object.extended
       first: 'overrided'
       second: 'second'
       third: 'third'
       footer: '.footer'
-    )
     target = (new @TestContainer()).__collectElements()
-    expect(target).toEqual(footer: '.footer')
+    expect(target).toEqual Object.extended(footer: '.footer')
 
   it "should resolve element selector", ->
-    target = @box.__extractSelector('$footer')
-    expect(target).toEqual('.footer')
+    target = @box.__extractSelector '$footer'
+    expect(target).toEqual '.footer'
 
   it "should inherit event declarations", ->
     class SubContainerA extends @TestContainer
@@ -68,27 +66,34 @@ describe "Joosy.Modules.Container", ->
         'custom' : 'overrided'
     subBox = new SubContainerB()
     target = subBox.__collectEvents()
-    expect(target).toEqual(
+    expect(target).toEqual Object.extended
       'test': 'onContainerTest'
       'test .post': 'callback2'
       'test $footer': 'onFooterTest'
       'custom' : 'overrided'
-    )
     target = (new @TestContainer()).__collectEvents()
-    expect(target).toEqual('test': 'onContainerTest')
+    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(
+    @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)
+    @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
+
+  it "calls afterRefreshes", ->
+    callback = sinon.spy()
+    @box.onRefresh -> callback()
+
+    @box.refreshElements()
+    @box.refreshElements()
+    expect(callback.callCount).toEqual 1

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

@@ -3,27 +3,64 @@ 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
 
-  it "should create the events waiters list", ->
-    expect(@box.__eventWaiters).toBeUndefined()
+    @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.wait('events  list', callback)
-    expect(@box.__eventWaiters).toEqual([[['events', '', 'list'], callback]])
-    expect(callback.callCount).toEqual(0)
 
-  it "should run callback once when the all listed events have occurred", ->
+    @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()
-    @box.wait('events   list', callback)
-    @box.trigger('events')
-    expect(callback.callCount).toEqual(0)
-    @box.trigger('list')
-    expect(callback.callCount).toEqual(0)
-    @box.trigger('')
-    expect(callback.callCount).toEqual(0)
-    @box.trigger('')
-    expect(callback.callCount).toEqual(1)
-    expect(@box.__eventWaiters).toEqual([])
-    @box.trigger('events')
-    expect(callback.callCount).toEqual(1)
+    @sub.wait 'foo', callback
+
+    expect(@sub.__oneShotEvents).toEqual [[['foo'], callback]]
+    expect(@box.__oneShotEvents).toBeUndefined()
+
+  it "should be safe for concurrent usage", ->
+    Joosy.synchronize (context) ->
+      context.do (done)  ->
+        window.setTimeout ->
+          expect(-> done()).not.toThrow()
+        , 1
+    Joosy.synchronize (context) ->
+      context.do (done)  ->
+        window.setTimeout ->
+          expect(-> done()).not.toThrow()
+        , 2
+    waits 3

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

@@ -16,13 +16,13 @@ describe "Joosy.Modules.Filters", ->
       @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'])
+    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'])
+    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()
@@ -30,42 +30,43 @@ describe "Joosy.Modules.Filters", ->
 
   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)
+    @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()
+      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)
+    callback[0].returns true
+    callback[1].returns false
+    @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)
+    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)
+    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)
+    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')
+    @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)
+      expect(@box['callback' + i].callCount).toEqual 1

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

@@ -6,10 +6,10 @@ describe "Joosy.Modules.Log", ->
     @box = new @TestLog()
 
   it "should log into console", ->
-    @box.log('message', 'appendix')
+    @box.log 'message', 'appendix'
 
   it "should log debug messages into console", ->
     Joosy.debug = true
-    @box.debug('debug message')
+    @box.debug 'debug message'
     Joosy.debug = false
-    @box.debug('unseen debug message')
+    @box.debug 'unseen debug message'

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

@@ -19,15 +19,15 @@ describe "Joosy.Module", ->
       property: 'value'
     class Klass extends Joosy.Module
       @include TestModule
-    expect(Klass::property).toEqual('value')
-    expect((new Klass()).property).toEqual('value')
+    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(Klass.property).toEqual 'value'
     expect((new Klass()).property).toBeUndefined()
 
   it "should run callbacks on include and extend", ->
@@ -39,18 +39,9 @@ describe "Joosy.Module", ->
       @include TestModule
       @extend TestModule
     for callback in ['included', 'extended']
-      expect(TestModule[callback].callCount).toEqual(1)
+      expect(TestModule[callback].callCount).toEqual 1
       expect(TestModule[callback].getCall(0).calledOn(Klass)).toBeTruthy()
 
-  it "should run init hook", ->
-    class Klass extends Joosy.Module
-      init: sinon.spy()
-    target = (new Klass(1, 2)).init
-    expect(target.callCount).toEqual(1)
-    expect(target.alwaysCalledWithExactly(1, 2)).toBeTruthy()
-
   it "should have minimal set of properties", ->
-    expect(Object.extended(Joosy.Module).keys())
-      .toEqual(['hasAncestor', 'include', 'extend'])
-    expect(Object.extended(Joosy.Module.prototype).keys())
-      .toEqual([])
+    expect(Object.extended(Joosy.Module).keys()).toEqual ['__namespace__', '__className', 'hasAncestor', 'merge', 'include', 'extend']
+    expect(Object.extended(Joosy.Module.prototype).keys()).toEqual []

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

@@ -0,0 +1,203 @@
+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 "updates contents, but only while it is bound to DOM", ->
+    @TestContainer.view (locals) ->
+      template = (locals) ->
+        "#{locals.object.value}"
+
+      @renderDynamic(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 "renders resources and keep html up2date", ->
+    data = Joosy.Resource.Generic.build zombie: 'rock'
+
+    @TestContainer.view (locals) ->
+      template = (locals) -> 
+        "#{locals.zombie}"
+
+      @renderDynamic(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 "renders collections and keep html up2date", ->
+    class Foo extends Joosy.Resource.Generic
+      @entity 'foo'
+
+    data = new Joosy.Resource.Collection(Foo)
+    
+    data.load [
+        { zombie: 'rock' },
+        { zombie: 'never sleep' }
+      ]
+
+    @TestContainer.view (locals) ->
+      template = (locals) ->
+        "#{locals.data[1] 'zombie'}"
+
+      @renderDynamic(template, locals)
+
+    elem = $("<div></div>")
+    @ground.append elem
+
+    elem.html @dummyContainer.__renderer(data)
+
+    waits 0
+
+    runs -> 
+      expect(elem.text()).toBe "never sleep"
+
+    runs ->
+      data.data[1] 'zombie', 'suck'
+    
+    waits 0 
+    
+    runs ->
+      expect(elem.text()).toBe "suck"
+
+
+  it "debounces morpher updates", ->
+    @TestContainer.view (locals) ->
+      template = (locals) ->
+        "#{locals.object.value}"
+  
+      @renderDynamic(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 "includes 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 "includes 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"
+
+  it "proxies onRefresh for containers", ->
+    class Box extends Joosy.Module
+      @include Joosy.Modules.Renderer
+      @include Joosy.Modules.Container
+
+    callback = sinon.spy()
+
+    Box.view (locals) ->
+      template = (locals) -> locals.onRefresh -> callback()
+      @render(template, locals)
+
+    box = new Box
+
+    box.__renderer({ })
+    box.refreshElements()
+
+    expect(callback.callCount).toEqual 1

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

@@ -7,14 +7,19 @@ describe "Joosy.Modules.TimeManager", ->
 
 
   it "should keep timeouts list", ->
-    timer = @box.setTimeout(10000, (->))
-    expect(@box.__timeouts).toEqual([timer])
-    window.clearTimeout(timer)
+    timer = @box.setTimeout 10000, ->
+    expect(@box.__timeouts).toEqual [timer]
+    window.clearTimeout timer
 
   it "should keep intervals list", ->
-    timer = @box.setInterval(10000, (->))
-    expect(@box.__intervals).toEqual([timer])
-    window.clearInterval(timer)
+    timer = @box.setInterval 10000, ->
+    expect(@box.__intervals).toEqual [timer]
+    window.clearInterval timer
 
   it "should stop intervals and timeouts", ->
-    @box.clearTime()
+    callback = sinon.spy()
+    runs ->
+      @box.setTimeout 10, callback
+      @box.__clearTime()
+    waits(10)
+    runs -> expect(callback.callCount).toEqual(0)

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

@@ -4,27 +4,26 @@ describe "Joosy.Modules.WidgetsManager", ->
     class @TestWidgetManager extends Joosy.Module
       @include Joosy.Modules.WidgetsManager
     @box = new @TestWidgetManager()
-    @widget_mock = Object.extended(
+    @widgetMock = Object.extended(
       __load: sinon.stub()
       __unload: sinon.spy()
     )
-    @widget_mock.__load.returns(@widget_mock)
+    @widgetMock.__load.returns @widgetMock
 
 
   it "should register and unregister widget", ->
-    expect(@box.registerWidget(@ground, @widget_mock)).toBe(@widget_mock)
-    expect(@box.__activeWidgets).toEqual([@widget_mock])
-    expect(@widget_mock.__load.callCount).toEqual(1)
+    expect(@box.registerWidget @ground, @widgetMock).toBe @widgetMock
+    expect(@box.__activeWidgets).toEqual [@widgetMock]
+    expect(@widgetMock.__load.callCount).toEqual 1
 
-    expect(@box.unregisterWidget(@widget_mock)).toBeTruthy()
-    expect(@box.__activeWidgets).toEqual([undefined])
-    expect(@widget_mock.__unload.callCount).toEqual(1)
+    expect(@box.unregisterWidget @widgetMock).toBeTruthy()
+    expect(@box.__activeWidgets).toEqual []
+    expect(@widgetMock.__unload.callCount).toEqual 1
 
   it "should unload all widgets", ->
-    0.upto(2).each =>
-      @box.registerWidget(@ground, @widget_mock)
+    0.upto(2).each => @box.registerWidget(@ground, @widgetMock)
     @box.__unloadWidgets()
-    expect(@widget_mock.__unload.callCount).toEqual(3)
+    expect(@widgetMock.__unload.callCount).toEqual 3
 
   it "should inherit widget declarations", ->
     @box.container = @ground
@@ -39,11 +38,10 @@ describe "Joosy.Modules.WidgetsManager", ->
         'selector': 'overriden'
     subBox = new SubWidgetManagerB()
     target = subBox.__collectWidgets()
-    expect(target).toEqual(
+    expect(target).toEqual Object.extended
       'test': 'widget'
       'widgets':  'widget'
       'selector': 'overriden'
-    )
 
   it "should register widgets per declaration", ->
     @seedGround()
@@ -53,9 +51,25 @@ describe "Joosy.Modules.WidgetsManager", ->
       '$container': Joosy.Widget
       '$footer': Joosy.Widget
       '.post': sinon.stub()
-    @box.widgets['.post'].returns(@widget_mock)
+    @box.widgets['.post'].returns @widgetMock
+    @box.__setupWidgets()
+    expect(@box.__activeWidgets.length).toEqual 5
+    expect(@box.widgets['.post'].callCount).toEqual 3
+    expect(@box.widgets['.post'].getCall(0).calledOn @box).toBeTruthy()
+
+  it "should bootstrap widget properly", ->
+    class TextWidget extends Joosy.Widget
+      @view -> 'fluffy'
+      constructor: (@tester) ->
+
+    @seedGround()
+    @box.container = $('#application')
+    @box.widgets =
+      '.post:first': TextWidget
+      '.widget:first': (i) -> new TextWidget i
     @box.__setupWidgets()
-    expect(@box.__activeWidgets.length).toEqual(5)
-    expect(@box.widgets['.post'].callCount).toEqual(3)
-    expect(@box.widgets['.post'].getCall(0).calledOn(@box))
 
+    expect(@ground.find('.post').html()).toEqual 'fluffy'
+    expect(@ground.find('.widget').html()).toEqual 'fluffy'
+    expect(@box.__activeWidgets[0].tester).toBeUndefined()
+    expect(@box.__activeWidgets[1].tester).toEqual 0