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

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

@@ -1,57 +1,62 @@
 describe "Joosy.Modules.Container", ->
 
   beforeEach ->
-    @seedGround()
+    @$ground.seed()
+    container = @$ground.find('#application')
 
-    class @TestContainer extends Joosy.Module
+    class @Container extends Joosy.Module
       @include Joosy.Modules.Container
+
       @mapElements
         posts: '.post'
         content:
           post1: '#post1'
           post2: '#post2'
         footer: '.footer'
+
       @mapEvents
         'test': 'onContainerTest'
-      container: $('#application', @ground)
 
-    @box = new @TestContainer()
+      container: container
+
+  it "swaps container", ->
+    initial = (new @Container).container
+    parent  = initial.parent()
+    event   = sinon.spy()
+
+    # Binded events trigger
+    initial.bind 'test', event
+    initial.trigger 'test'
+    expect(event.callCount).toEqual 1
 
-  it "reinitializes container", ->
-    oldContainer = @box.container
-    parent       = oldContainer.parent()
-    callback     = sinon.spy()
+    swapped = Joosy.Modules.Container.swapContainer initial, 'new content'
 
-    oldContainer.bind 'test', callback
-    oldContainer.trigger 'test'
-    expect(callback.callCount).toEqual 1
+    # Injects into DOM properly
+    expect(swapped.html()).toEqual 'new content'
+    expect(swapped.parent().get 0).toEqual parent.get 0
 
-    newContainer = Joosy.Modules.Container.swapContainer oldContainer, 'new content'
-    newContainer.trigger 'test'
-    expect(newContainer.html()).toEqual 'new content'
-    expect(newContainer.parent().get(0)).toBe parent.get 0
-    expect(callback.callCount).toEqual 1
+    # Binded events disappear
+    swapped.trigger 'test'
+    expect(event.callCount).toEqual 1
 
-  it "calls afterRefreshes", ->
-    callback = sinon.spy()
-    @box.onRefresh -> callback()
+  describe "elements assigner", ->
 
-    @box.refreshElements()
-    @box.refreshElements()
-    expect(callback.callCount).toEqual 1
+    beforeEach ->
+      @container = new @Container
+      @container.__assignElements()
 
-  describe "elements", ->
     it "declares", ->
-      class SubContainerA extends @TestContainer
+      class A extends @Container
         @mapElements
           first: 'first'
           second: 'second'
-      class SubContainerB extends SubContainerA
+
+      class B extends A
         @mapElements
           first: 'overrided'
           third: 'third'
 
-      expect((new SubContainerB()).__elements).toEqual Object.extended
+      expect((new B).__elements).toEqual Object.extended
         posts: '.post'
         content: 
           post1: '#post1'
@@ -61,90 +66,88 @@ describe "Joosy.Modules.Container", ->
         third: 'third'
         footer: '.footer'
 
-      expect((new @TestContainer()).__elements).toEqual Object.extended
+      expect((new @Container).__elements).toEqual Object.extended
         posts: '.post'
         footer: '.footer'
         content: 
           post1: '#post1'
           post2: '#post2'
 
-      console.log (new @TestContainer)
-
-    it "resolve selector", ->
-      @box.__assignElements()
-
-      target = @box.__extractSelector '$footer'
-      expect(target).toEqual '.footer'
-
-      target = @box.__extractSelector '$content.$post1'
-      expect(target).toEqual '#post1'
+    describe "selector resolvance", ->
 
-      target = @box.__extractSelector '$footer tr'
-      expect(target).toEqual '.footer tr'
+      it "works for plane selectors", ->
+        expect(@container.__extractSelector '$footer').toEqual '.footer'
 
-      target = @box.__extractSelector '$footer $content.$post1'
-      expect(target).toEqual '.footer #post1'
+      it "works for deep selectors", ->
+        expect(@container.__extractSelector '$content.$post1').toEqual '#post1'
 
-    it "nesteds get assigned", ->
-      @box.__assignElements()
-      expect(@box.$content.$post1().get 0).toBe $('#post1').get 0
+      it "works for plane extended selectors", ->
+        expect(@container.__extractSelector '$footer tr').toEqual '.footer tr'
 
-    it "get assigned", ->
-      @box.__assignElements()
+      it "works for deep extended selectors", ->
+        expect(@container.__extractSelector '$footer $content.$post1').toEqual '.footer #post1'
 
-      target = @box.$footer().get 0
+    it "assigns", ->
+      target = @container.$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', @container.container).get 0
+      expect(target).toBe @container.$('.footer').get 0
 
-    it "allow to filter", ->
-      @box.__assignElements()
+    it "assigns nesteds", ->
+      expect(@container.$content.$post1().get 0).toBe $('#post1').get 0
 
-      target = @box.$posts('#post1').get 0
+    it "filters assignation", ->
+      target = @container.$posts('#post1').get 0
       expect(target).toBeTruthy()
-      expect(target).toBe $('#post1', @box.container).get 0
+      expect(target).toBe $('#post1', @container.container).get 0
 
-    it "respect container boundaries", ->
-      @box.__assignElements()
+    it "respects container boundaries", ->
+      @$ground.prepend('<div class="footer" />')  # out of container
 
-      @ground.prepend('<div class="footer" />')  # out of container
-      target = @box.$footer().get 0
+      target = @container.$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', @container.container).get 0
+      expect(target).toBe @container.$('.footer').get 0
+
+  describe "events delegator", ->
 
-  describe "events", ->
     it "declares", ->
-      class SubContainerA extends @TestContainer
+      class A extends @Container
         @mapEvents
           'test .post': 'callback2'
           'custom' : 'method'
-      class SubContainerB extends SubContainerA
+
+      class B extends A
         @mapEvents
           'test $footer': 'onFooterTest'
           'custom' : 'overrided'
-      target = (new SubContainerB()).__events
-      expect(target).toEqual Object.extended
+
+      expect((new B).__events).toEqual Object.extended
         'test': 'onContainerTest'
         'test .post': 'callback2'
         'test $footer': 'onFooterTest'
         'custom' : 'overrided'
-      target = (new @TestContainer()).__events
-      expect(target).toEqual Object.extended('test': 'onContainerTest')
 
-    it "delegate", ->
-      @box.__assignElements()
+      expect((new @Container).__events).toEqual Object.extended
+        'test': 'onContainerTest'
+
+    it "delegates", ->
       callbacks = 1.upto(3).map -> sinon.spy()
-      @box.__events = Object.extended(@box.__events).merge
+
+      @Container.mapEvents
         'test .post': callbacks[2]
         'test $footer': 'onFooterTest'
+      @Container::onContainerTest = callbacks[0]
+      @Container::onFooterTest = callbacks[1]
+
+      container = new @Container
+      container.__assignElements()
+      container.__delegateEvents()
+
+      container.container.trigger 'test'
+      $('.footer', container.container).trigger 'test'
+      $('.post', container.container).trigger 'test'
 
-      @box.onContainerTest = callbacks[0]
-      @box.onFooterTest = callbacks[1]
-      @box.__delegateEvents()
-      @box.container.trigger 'test'
-      $('.footer', @box.container).trigger 'test'
-      $('.post', @box.container).trigger 'test'
       expect(callbacks[0].callCount).toEqual 5
       expect(callbacks[1].callCount).toEqual 1
-      expect(callbacks[2].callCount).toEqual 3
+      expect(callbacks[2].callCount).toEqual 3

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

@@ -1,111 +1,178 @@
 describe "Joosy.Modules.Events", ->
 
   beforeEach ->
-    class @TestEvents extends Joosy.Module
+    class @Eventer 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()
+  describe "base", ->
+
+    beforeEach ->
+      @callback = sinon.spy()
+      @eventer  = new @Eventer
+
+    describe "waiter", ->
+
+      it "fires", ->
+        @eventer.wait 'events list', @callback
+
+        @eventer.trigger 'events'
+        expect(@callback.callCount).toEqual 0
+
+        @eventer.trigger 'list'
+        expect(@callback.callCount).toEqual 1
+
+      it "fires just once", ->
+        @eventer.wait 'events list', @callback
+
+        @eventer.trigger 'events'
+        @eventer.trigger 'list'
+        @eventer.trigger 'events'
+        @eventer.trigger 'list'
+
+        expect(@callback.callCount).toEqual 1
+
+      it "unbinds", ->
+        binding = @eventer.wait 'events list', @callback
+        @eventer.unwait binding
+
+        @eventer.trigger 'events'
+        @eventer.trigger 'list'
+
+        expect(@callback.callCount).toEqual 0
+
+      it "recognizes invalid arguments", ->
+        expect(=> @eventer.wait '', @callback).toThrow()
+        expect(=> @eventer.wait '    ', @callback).toThrow()
+        expect(=> @eventer.wait [], @callback).toThrow()
+
+    describe "binder", ->
+
+      it "fires", ->
+        @eventer.bind 'events list', @callback
+
+        @eventer.trigger 'events'
+        expect(@callback.callCount).toEqual 1
+
+        @eventer.trigger 'list'
+        expect(@callback.callCount).toEqual 2
+
+      it "fires multiple times", ->
+        @eventer.bind 'events list', @callback
+
+        @eventer.trigger 'events'
+        @eventer.trigger 'list'
+        @eventer.trigger 'events'
+        @eventer.trigger 'list'
+
+        expect(@callback.callCount).toEqual 4
+
+      it "unbinds", ->
+        binding = @eventer.bind 'events list', @callback
+        @eventer.unbind binding
+
+        @eventer.trigger 'events'
+        @eventer.trigger 'list'
+
+        expect(@callback.callCount).toEqual 0
+
+      it "recognizes invalid arguments", ->
+        expect(=> @eventer.bind '', @callback).toThrow()
+        expect(=> @eventer.bind '    ', @callback).toThrow()
+        expect(=> @eventer.bind [], @callback).toThrow()
+
+    it "allows simultaneous usage", ->
+      3.times (i) => @eventer.bind "event#{i}", @callback
+      3.times (i) => @eventer.wait "event#{i}", @callback
+
+      @eventer.trigger 'event2'
+
+      expect(@callback.callCount).toEqual 2
+
+    it "handles inheritance well", ->
+      class A extends @Eventer
+      a = new A
+
+      a.wait 'event', @callback
 
-    @box.wait '  events   list ', callback
+      expect(a.__oneShotEvents).toEqual 0: [['event'], @callback]
+      expect(@eventer.__oneShotEvents).toBeUndefined()
 
-    @box.trigger 'events'
-    expect(callback.callCount).toEqual 0
-    @box.trigger 'list'
-    expect(callback.callCount).toEqual 1
+  describe "synchronizer", ->
 
-    @box.trigger 'events'
-    expect(callback.callCount).toEqual 1
-    @box.trigger 'list'
-    expect(callback.callCount).toEqual 1
+    it "finalizes", ->
+      callback = sinon.spy()
 
-    expect(=> @box.wait '', callback).toThrow()
-    expect(callback.callCount).toEqual 1
+      Joosy.Modules.Events.synchronize (context) ->
+        context.do (done) ->
+          callback()
+          done()
+        context.after ->
+          expect(callback.callCount).toEqual 1
+          callback()
 
-    expect(=> @box.wait '    ', callback).toThrow()
-    expect(callback.callCount).toEqual 1
+      waits 1
+      expect(callback.callCount).toEqual 2
 
-    expect(=> @box.wait [], callback).toThrow()
-    expect(callback.callCount).toEqual 1
+    it "finalizes with no dependencies defined", ->
+      callback = sinon.spy()
 
-  it "should allow for binding and unbinding to events", ->
-    callback = sinon.spy()
+      Joosy.Modules.Events.synchronize (context) ->
+        context.after ->
+          expect(callback.callCount).toEqual 0
+          callback()
 
-    @box.bind 'event', callback
+      waits 1
+      expect(callback.callCount).toEqual 1
 
-    @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
+    it "gets called in proper context", ->
+      eventer = new @Eventer
 
-    @box.unbind 'other-event'
+      eventer.synchronize (context) ->
+        context.do (done) ->
+          expect(@).toEqual eventer
+        context.after ->
 
-    @box.trigger 'event'
-    expect(callback.callCount).toEqual 3
+    it "is safe for concurrent usage", ->
+      test = (method) ->
+        expect(-> method()).not.toThrow()
 
-    @box.unbind callback
+      Joosy.Modules.Events.synchronize (context) ->
+        context.do (done)  ->
+          window.setTimeout (-> test done), 1
 
-    @box.trigger 'event'
-    expect(callback.callCount).toEqual 3
+      Joosy.Modules.Events.synchronize (context) ->
+        context.do (done)  ->
+          window.setTimeout (-> test done), 2
 
-  it "should allow multiple binding", ->
-    callback = ->
+      waits 3
 
-    3.times =>
-      @box.bind 'event', callback
-    expect(@box.__boundEvents).toEqual 0: [['event'], callback], 1: [['event'], callback],  2: [['event'], callback]
+  describe "namespece", ->
 
-    3.times =>
-      @box.wait 'event', callback
-    expect(@box.__oneShotEvents).toEqual 0: [['event'], callback], 1: [['event'], callback], 2: [['event'], callback]
+    beforeEach ->
+      @callback = sinon.spy()
 
-  it "should handle inheritance well", ->
-    callback = sinon.spy()
-    @sub.wait 'foo', callback
+    it "proxies events", ->
+      eventer   = new @Eventer
+      namespace = new Joosy.Events.Namespace(eventer)
 
-    expect(@sub.__oneShotEvents).toEqual 0: [['foo'], callback]
-    expect(@box.__oneShotEvents).toBeUndefined()
+      namespace.bind 'event1', @callback
+      namespace.bind 'event2', @callback
 
-  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
+      eventer.trigger 'event1'
+      eventer.trigger 'event2'
 
-  it "should call finalizer", ->
-    callback = sinon.spy()
+      expect(@callback.callCount).toEqual 2
 
-    Joosy.synchronize (context) ->
-      context.do (done) ->
-        callback()
-        done()
-      context.after ->
-        expect(callback.callCount).toEqual 1
-        callback()
+    it "unbinds events", ->
+      eventer   = new @Eventer
+      namespace = new Joosy.Events.Namespace(eventer)
 
-    waits 1
-    expect(callback.callCount).toEqual 2
+      namespace.bind 'event1', @callback
+      namespace.bind 'event2', @callback
 
-  it "should call finalizer even if context.do hasn't been called", ->
-    callback = sinon.spy()
+      namespace.unbind()
 
-    Joosy.synchronize (context) ->
-      context.after ->
-        expect(callback.callCount).toEqual 0
-        callback()
+      eventer.trigger 'event1'
+      eventer.trigger 'event2'
 
-    waits 1
-    expect(callback.callCount).toEqual 1
+      expect(@callback.callCount).toEqual 0

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

@@ -1,72 +1,91 @@
 describe "Joosy.Modules.Filters", ->
 
   beforeEach ->
-    class @TestFilters extends Joosy.Module
+    class @Filters extends Joosy.Module
       @include Joosy.Modules.Filters
-    @box = new @TestFilters()
 
+    @filters = new @Filters
 
-  it "should inherit filters by copying them", ->
-    class SubFiltersA extends @TestFilters
+  it "inherits filters by copying them", ->
+    class A extends @Filters
       @beforeLoad 'filter1'
       @afterLoad 'filter2'
       @afterUnload 'filter3'
-    class SubFiltersB extends SubFiltersA
+
+    class B extends A
       @beforeLoad 'filter4'
       @afterLoad 'filter5'
       @afterUnload 'filter6'
-    target = new SubFiltersB()
+
+    target = new B
     expect(target.__beforeLoads).toEqual ['filter1', 'filter4']
     expect(target.__afterLoads).toEqual ['filter2', 'filter5']
     expect(target.__afterUnloads).toEqual ['filter3', 'filter6']
-    target = new SubFiltersA()
+
+    target = new A
     expect(target.__beforeLoads).toEqual ['filter1']
     expect(target.__afterLoads).toEqual ['filter2']
     expect(target.__afterUnloads).toEqual ['filter3']
-    target = new @TestFilters()
+
+    target = new @Filters
     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
-    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
-
-  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()
+  it "runs callbacks", ->
+    callbacks = 0.upto(2).map -> sinon.spy()
+    @Filters.beforeLoad callbacks[0]
+    @Filters.afterLoad callbacks[1]
+    @Filters.afterUnload callbacks[2]
+
+    @filters.__runBeforeLoads 1, 2
+    @filters.__runAfterLoads 1, 2
+    @filters.__runAfterUnloads 1, 2
+
     for i in 0.upto(2)
-      expect(@box['callback' + i].callCount).toEqual 1
+      expect(callbacks[i].callCount).toEqual 1
+      expect(callbacks[i].alwaysCalledWithExactly 1, 2).toBeTruthy()
+
+  describe "chaining", ->
+
+    it "evaluates", ->
+      callbacks = 0.upto(1).map =>
+        callback = sinon.stub()
+        @Filters.beforeLoad callback
+        callback
+
+      callbacks[0].returns true
+      callbacks[1].returns true
+
+      expect(@filters.__runBeforeLoads()).toBeTruthy()
+
+      expect(callbacks[0].callCount).toEqual 1
+      expect(callbacks[1].callCount).toEqual 1
+
+    it "breaks on false", ->
+      callbacks = 0.upto(2).map =>
+        callback = sinon.stub()
+        @Filters.beforeLoad callback
+        callback
+
+      callbacks[0].returns true
+      callbacks[1].returns false
+
+      expect(@filters.__runBeforeLoads()).toBeFalsy()
+
+      expect(callbacks[0].callCount).toEqual 1
+      expect(callbacks[1].callCount).toEqual 1
+      expect(callbacks[2].callCount).toEqual 0
+
+  it "accepts method names as callbacks", ->
+    @filters['callback' + i] = sinon.spy() for i in 0.upto(2)
+
+    @Filters.beforeLoad  'callback0'
+    @Filters.afterLoad   'callback1'
+    @Filters.afterUnload 'callback2'
+      
+    @filters.__runBeforeLoads()
+    @filters.__runAfterLoads()
+    @filters.__runAfterUnloads()
+
+    expect(@filters['callback' + i].callCount).toEqual 1 for i in 0.upto(2)

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

@@ -1,15 +1,23 @@
 describe "Joosy.Modules.Log", ->
 
   beforeEach ->
-    class @TestLog extends Joosy.Module
+    class @Logger extends Joosy.Module
       @include Joosy.Modules.Log
-    @box = new @TestLog()
+
+    @logger = new @Logger
+    @stub   = sinon.stub console, 'log'
+
+  afterEach ->
+    console.log.restore()
 
   it "should log into console", ->
-    @box.log 'message', 'appendix'
+    @logger.log 'message', 'appendix'
+    expect(@stub.callCount).toEqual 1
 
   it "should log debug messages into console", ->
     Joosy.Application.config.debug = true
-    @box.debug 'debug message'
+    @logger.debug 'debug message'
     Joosy.Application.config.debug = false
-    @box.debug 'unseen debug message'
+    @logger.debug 'unseen debug message'
+
+    expect(@stub.callCount).toEqual 1