joosy 1.2.0.alpha.38 → 1.2.0.alpha.41

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

@@ -1,47 +1,57 @@
 describe "Joosy.Module", ->
 
-  it "should track inheritance", ->
+  it "tracks 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()
+            expect(Joosy.Module.hasAncestor a, b).toBeTruthy()
         else
-          expect(Joosy.Module.hasAncestor.apply(null, [a, b])).toBeFalsy()
+          expect(Joosy.Module.hasAncestor a, b).toBeFalsy()
 
-  it "should include properties into prototype", ->
-    TestModule =
+  # We need this check to ensure we are not overpolluting the namespace
+  it "has minimal set of properties", ->
+    class Klass extends Joosy.Module
+
+    expect(Object.extended(Klass).keys()).toEqual ['__namespace__', '__className', 'hasAncestor', 'aliasMethodChain', 'aliasStaticMethodChain', 'merge', 'include', 'extend', '__super__']
+    expect(Object.extended(Klass.prototype).keys()).toEqual ['constructor']
+
+  it "includes", ->
+    Module =
       property: 'value'
+
     class Klass extends Joosy.Module
-      @include TestModule
+      @include Module
+
     expect(Klass::property).toEqual 'value'
-    expect((new Klass()).property).toEqual 'value'
+    expect(Klass.property).toBeUndefined()
 
-  it "should extend object", ->
+  it "extends", ->
     TestModule =
       property: 'value'
+
     class Klass extends Joosy.Module
       @extend TestModule
+
     expect(Klass.property).toEqual 'value'
-    expect((new Klass()).property).toBeUndefined()
+    expect(Klass::property).toBeUndefined()
 
-  it "should run callbacks on include and extend", ->
+  it "runs callbacks", ->
     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', 'alias', 'aliasStatic', 'merge', 'include', 'extend']
-    expect(Object.extended(Joosy.Module.prototype).keys()).toEqual []

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

@@ -1,136 +1,142 @@
 describe "Joosy.Modules.Renderer", ->
 
   beforeEach ->
-    @seedGround()
-
-    class @TestContainer extends Joosy.Module
+    class @Renderer extends Joosy.Module
       @include Joosy.Modules.Renderer
 
-    @dummyContainer = new @TestContainer
-
-    class @TestObject extends Joosy.Module
-      @include Joosy.Modules.Events
-
-      constructor: (@value) ->
+    @renderer = new @Renderer
 
-      update: (@value) ->
-        @trigger 'changed'
+  it "renders default template", ->
+    template = sinon.stub()
+    template.returns "result"
 
-    @dummyObject = new @TestObject("initial")
+    @Renderer.view template
 
-    Joosy.namespace 'Joosy.Helpers.Hoge', ->
-      @multiplier = (value) ->
-        "#{value * 5}"
+    expect(@renderer.__renderDefault(foo: 'bar')).toEqual 'result'
+    expect(template.getCall(0).args[0].foo).toEqual 'bar'
+    expect(template.getCall(0).args[0].__renderer).toEqual @renderer
 
-  it "updates contents, but only while it is bound to DOM", ->
-    @TestContainer.view (locals) ->
-      template = -> @object.value
+  describe "rendering", ->
+    beforeEach ->
+      @template = (locals) =>
+        expect(locals.foo).toEqual 'bar'
+        expect(locals.__renderer).toEqual @renderer
+        "result"
 
-      @renderDynamic(template, locals)
+    it "accepts lambda", ->
+      expect(@renderer.render @template, foo: 'bar').toEqual 'result'
 
-    elem = $("<div></div>")
-    @ground.append elem
+    it "accepts template", ->
+      target = sinon.stub Joosy.Application.templater, 'buildView'
+      target.returns @template
 
-    elem.html @dummyContainer.__renderer({ object: @dummyObject })
-    expect(elem.text()).toBe "initial"
+      expect(@renderer.render @template, foo: 'bar').toEqual 'result'
 
-    @dummyObject.update "new"
+      Joosy.Application.templater.buildView.restore()
 
-    waits 0
+  describe "dynamic rendering", ->
+    beforeEach ->
+      # Instance we are going to use to trigger dynamic rendering
+      class @Entity extends Joosy.Module
+        @include Joosy.Modules.Events
 
-    runs ->
-      expect(elem.text()).toBe "new"
+        constructor: (@value) ->
 
-    waits 0
+        update: (@value) ->
+          @trigger 'changed'
 
-    runs ->
-      @dummyContainer.__removeMetamorphs()
-      @dummyObject.update "afterwards"
+      @entity = new @Entity("initial")
 
-    waits 0
+    it "updates content", ->
+      template = (locals) -> locals.entity.value
 
-    runs ->
-      expect(elem.text()).toBe "new"
+      runs ->
+        @$ground.html @renderer.renderDynamic(template, entity: @entity)
+        expect(@$ground.text()).toBe "initial"
 
-  it "debounces morpher updates", ->
-    @TestContainer.view (locals) ->
-      template = -> @object.value
+      runs ->
+        @entity.update "new"
 
-      @renderDynamic(template, locals)
+      waits 0
 
-    elem = $("<div></div>")
-    @ground.append elem
+      runs ->
+        expect(@$ground.text()).toBe "new"
 
-    sinon.spy window, 'Metamorph'
+    it "does not update unloaded content", ->
+      template = (locals) -> locals.entity.value
 
-    elem.html @dummyContainer.__renderer({ object: @dummyObject })
-    expect(elem.text()).toBe "initial"
+      runs ->
+        @$ground.html @renderer.renderDynamic(template, entity: @entity)
+        expect(@$ground.text()).toBe "initial"
+        @renderer.__removeMetamorphs()
 
-    updater = sinon.spy window.Metamorph.returnValues[0], 'html'
+      runs ->
+        @entity.update "new"
 
-    @dummyObject.update "new"
+      waits 0
 
-    waits 0
+      runs ->
+        expect(@$ground.text()).toBe "initial"
 
-    runs ->
-      expect(elem.text()).toBe "new"
-      expect(updater.callCount).toEqual 1
+    describe "Metamorph magic", ->
+      beforeEach ->
+        sinon.spy window, 'Metamorph'
 
-    runs ->
-      @dummyObject.update "don't make"
-      @dummyObject.update "me evil"
+        template = (locals) -> locals.entity.value
+        @$ground.html @renderer.renderDynamic(template, entity: @entity)
 
-    waits 0
+        # With this we intercept calls to Metamorph updates
+        @updater = sinon.spy window.Metamorph.returnValues[0], 'html'
 
-    runs ->
-      expect(elem.text()).toBe "me evil"
-      expect(updater.callCount).toEqual 2
+      afterEach ->
+        Metamorph.restore()
 
-  it "includes rendering helpers in locals", ->
-    @TestContainer.helpers "Hoge"
+      it "debounces", ->
+        @entity.update "new"
+        @entity.update "don't make"
+        @entity.update "me evil"
 
-    @TestContainer.view (locals) ->
-      template = (locals) -> @multiplier(10)
+        waits 0
 
-      @render(template, locals)
+        runs ->
+          expect(@updater.callCount).toEqual 1
+          expect(@$ground.text()).toEqual "me evil"
 
-    elem = $("<div></div>")
-    @ground.append elem
+      it "catches manually removed nodes", ->
+        @$ground.html ''
 
-    elem.html @dummyContainer.__renderer({ })
+        @entity.update "new"
+        @entity.update "don't make"
+        @entity.update "me evil"
 
-    expect(elem.text()).toBe "50"
+        waits 0
 
-  it "includes global rendering helpers in locals", ->
-    Joosy.Helpers.Application.globalMultiplier = (value) ->
-      value * 6
+        runs ->
+          expect(@updater.callCount).toEqual 0
 
-    @TestContainer.view (locals) ->
-      template = (locals) -> @globalMultiplier(10)
+  describe "helpers includer", ->
 
-      @render(template, locals)
+    it "works with modules", ->
+      Joosy.namespace 'Joosy.Helpers.Hoge', ->
+        @multiplier = (value) -> "#{value * 5}"
 
-    elem = $("<div></div>")
-    @ground.append elem
+      @Renderer.helper Joosy.Helpers.Hoge
+      template = (locals) -> locals.multiplier(10)
 
-    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
+      expect(@renderer.render template).toBe "50"
 
-    callback = sinon.spy()
+    it "works with local methods", ->
+      @Renderer::multiplier = (value) -> "#{value * 10}"
+      @Renderer.helper 'multiplier'
+      template = (locals) -> locals.multiplier(10)
 
-    Box.view (locals) ->
-      template = -> @onRefresh -> callback()
-      @render(template, locals)
+      expect(@renderer.render template).toBe "100"
+      delete @Renderer::multiplier
 
-    box = new Box
+    it "works with globals", ->
+      Joosy.Helpers.Application.multiplier = (value) -> "#{value * 3}"
+      template = (locals) -> locals.multiplier(10)
 
-    box.__renderer({ })
-    box.refreshElements()
+      expect(@renderer.render template).toBe "30"
+      delete Joosy.Helpers.Application.multiplier
 
-    expect(callback.callCount).toEqual 1

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

@@ -1,25 +1,20 @@
 describe "Joosy.Modules.TimeManager", ->
 
   beforeEach ->
-    class @TestTimeManager extends Joosy.Module
+    class @Manager extends Joosy.Module
       @include Joosy.Modules.TimeManager
-    @box = new @TestTimeManager()
 
+    @manager = new @Manager
 
-  it "should keep timeouts list", ->
-    timer = @box.setTimeout 10000, ->
-    expect(@box.__timeouts).toEqual [timer]
-    window.clearTimeout timer
+  it "stops intervals and timeouts", ->
+    callback = sinon.spy()
+
+    runs ->
+      @manager.setTimeout 1, callback
+      @manager.setInterval 1, callback
+      @manager.__clearTime()
 
-  it "should keep intervals list", ->
-    timer = @box.setInterval 10000, ->
-    expect(@box.__intervals).toEqual [timer]
-    window.clearInterval timer
+    waits 2
 
-  it "should stop intervals and timeouts", ->
-    callback = sinon.spy()
     runs ->
-      @box.setTimeout 10, callback
-      @box.__clearTime()
-    waits(10)
-    runs -> expect(callback.callCount).toEqual(0)
+      expect(callback.callCount).toEqual 0

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

@@ -1,78 +1,96 @@
 describe "Joosy.Modules.WidgetsManager", ->
 
   beforeEach ->
-    class @TestWidgetManager extends Joosy.Module
-      @include Joosy.Modules.WidgetsManager
+    class @Manager extends Joosy.Module
       @include Joosy.Modules.Container
+      @include Joosy.Modules.WidgetsManager
+
+    class @Widget extends Joosy.Widget
+      constructor: (@argument) ->
+
+    @manager = new @Manager
+
+  describe "manager", ->
+
+    beforeEach ->
+      @widget = new @Widget
+
+      sinon.spy @widget, '__load'
+      sinon.spy @widget, '__unload'
+
+    it "registers widget", ->
+      result = @manager.registerWidget @$ground, @widget
+      expect(result instanceof @Widget).toBeTruthy()
+      expect(@manager.__activeWidgets).toEqual [result]
+      expect(@widget.__load.callCount).toEqual 1
+
+    it "unregisters widget", ->
+      @manager.registerWidget @$ground, @widget
+
+      expect(@manager.unregisterWidget @widget).toBeTruthy()
+      expect(@manager.__activeWidgets).toEqual []
+      expect(@widget.__unload.callCount).toEqual 1
+
+    it "unload all widgets properly", ->
+      3.times => @manager.registerWidget(@$ground, @widget)
+      @manager.__unloadWidgets()
+      expect(@widget.__unload.callCount).toEqual 3
+
+  describe 'declarator', ->
+
+    it "inherits widget declarations", ->
+      @Manager.mapWidgets
+        'test': 'widget'
 
-    @box = new @TestWidgetManager()
-    @widgetMock = Object.extended(
-      __load: sinon.stub()
-      __unload: sinon.spy()
-    )
-    @widgetMock.__load.returns @widgetMock
-
-
-  it "should register and unregister widget", ->
-    expect(@box.registerWidget @ground, @widgetMock).toBe @widgetMock
-    expect(@box.__activeWidgets).toEqual [@widgetMock]
-    expect(@widgetMock.__load.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, @widgetMock)
-    @box.__unloadWidgets()
-    expect(@widgetMock.__unload.callCount).toEqual 3
-
-  it "should inherit widget declarations", ->
-    @box.container = @ground
-    @TestWidgetManager::__widgets =
-      'test': 'widget'
-    class SubWidgetManagerA extends @TestWidgetManager
-      @mapWidgets
+      class A extends @Manager
+        @mapWidgets
+          'selector': 'widget'
+
+      class B extends A
+        @mapWidgets
+          'widgets': 'widget'
+          'selector': 'overriden'
+
+      expect((new A).__widgets).toEqual Object.extended
+        'test': 'widget'
         'selector': 'widget'
-    class SubWidgetManagerB extends SubWidgetManagerA
-      @mapWidgets
-        'widgets': 'widget'
+
+      expect((new B).__widgets).toEqual Object.extended
+        'test': 'widget'
+        'widgets':  'widget'
         'selector': 'overriden'
-    subBox = new SubWidgetManagerB()
-    target = subBox.__widgets
-    expect(target).toEqual Object.extended
-      'test': 'widget'
-      'widgets':  'widget'
-      'selector': 'overriden'
-
-  it "should register widgets per declaration", ->
-    @seedGround()
-    @box.container = $('#application')
-    @box.__elements = {footer: '.footer'}
-    @box.__widgets =
-      '$container': Joosy.Widget
-      '$footer': Joosy.Widget
-      '.post': sinon.stub()
-    @box.__widgets['.post'].returns @widgetMock
-    @box.__assignElements()
-    @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(@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
+
+    it "registers declared widgets", ->
+      @$ground.seed()
+
+      @Manager.mapElements
+        footer: '.footer'
+
+      @Manager.mapWidgets widgets =
+        '$container': Joosy.Widget
+        '$footer': Joosy.Widget
+        '.post': sinon.stub().returns new @Widget
+
+      @manager.container = $('#application')
+      @manager.__assignElements()
+      @manager.__setupWidgets()
+
+      expect(@manager.__activeWidgets.length).toEqual 5
+      expect(widgets['.post'].callCount).toEqual 3
+      expect(widgets['.post'].getCall(0).calledOn @manager).toBeTruthy()
+
+    it "bootstraps declared widgets properly", ->
+      @$ground.seed()
+
+      @Widget.view -> 'fluffy'
+      @Manager.mapWidgets
+        '#post1': @Widget
+        '#widget1': (i) => new @Widget i
+
+      @manager.container = $('#application')
+      @manager.__setupWidgets()
+
+      expect(@$ground.find('#post1').html()).toEqual 'fluffy'
+      expect(@$ground.find('#widget1').html()).toEqual 'fluffy'
+      expect(@manager.__activeWidgets[0].argument).toBeUndefined()
+      expect(@manager.__activeWidgets[1].argument).toEqual 0