joosy 1.2.0.alpha.41 → 1.2.0.alpha.51

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

@@ -0,0 +1,133 @@
+describe "Joosy.Modules.DOM", ->
+
+  beforeEach ->
+    @$ground.seed()
+    container = @$ground.find('#application')
+
+    class @DOM extends Joosy.Module
+      @include Joosy.Modules.DOM
+
+      @mapElements
+        posts: '.post'
+        content:
+          post1: '#post1'
+          post2: '#post2'
+        footer: '.footer'
+
+      @mapEvents
+        'test': 'onDOMTest'
+
+      $container: container
+
+  describe "elements assigner", ->
+
+    beforeEach ->
+      @dom = new @DOM
+      @dom.__assignElements()
+
+    it "declares", ->
+      class A extends @DOM
+        @mapElements
+          first: 'first'
+          second: 'second'
+
+      class B extends A
+        @mapElements
+          first: 'overrided'
+          third: 'third'
+
+      expect((new B).__elements).toEqual Object.extended
+        posts: '.post'
+        content: 
+          post1: '#post1'
+          post2: '#post2'
+        first: 'overrided'
+        second: 'second'
+        third: 'third'
+        footer: '.footer'
+
+      expect((new @DOM).__elements).toEqual Object.extended
+        posts: '.post'
+        footer: '.footer'
+        content: 
+          post1: '#post1'
+          post2: '#post2'
+
+    describe "selector resolvance", ->
+
+      it "works for plane selectors", ->
+        expect(@dom.__extractSelector '$footer').toEqual '.footer'
+
+      it "works for deep selectors", ->
+        expect(@dom.__extractSelector '$content.$post1').toEqual '#post1'
+
+      it "works for plane extended selectors", ->
+        expect(@dom.__extractSelector '$footer tr').toEqual '.footer tr'
+
+      it "works for deep extended selectors", ->
+        expect(@dom.__extractSelector '$footer $content.$post1').toEqual '.footer #post1'
+
+    it "assigns", ->
+      target = @dom.$footer().get 0
+      expect(target).toBeTruthy()
+      expect(target).toBe $('.footer', @dom.$container).get 0
+      expect(target).toBe @dom.$('.footer').get 0
+
+    it "assigns nesteds", ->
+      expect(@dom.$content.$post1().get 0).toBe $('#post1').get 0
+
+    it "filters assignation", ->
+      target = @dom.$posts('#post1').get 0
+      expect(target).toBeTruthy()
+      expect(target).toBe $('#post1', @dom.$container).get 0
+
+    it "respects container boundaries", ->
+      @$ground.prepend('<div class="footer" />')  # out of container
+
+      target = @dom.$footer().get 0
+      expect(target).toBeTruthy()
+      expect(target).toBe $('.footer', @dom.$container).get 0
+      expect(target).toBe @dom.$('.footer').get 0
+
+  describe "events delegator", ->
+
+    it "declares", ->
+      class A extends @DOM
+        @mapEvents
+          'test .post': 'callback2'
+          'custom' : 'method'
+
+      class B extends A
+        @mapEvents
+          'test $footer': 'onFooterTest'
+          'custom' : 'overrided'
+
+      expect((new B).__events).toEqual Object.extended
+        'test': 'onDOMTest'
+        'test .post': 'callback2'
+        'test $footer': 'onFooterTest'
+        'custom' : 'overrided'
+
+      expect((new @DOM).__events).toEqual Object.extended
+        'test': 'onDOMTest'
+
+    it "delegates", ->
+      callbacks = 1.upto(3).map -> sinon.spy()
+
+      @DOM.mapEvents
+        'test .post': callbacks[2]
+        'test $footer': 'onFooterTest'
+      @DOM::onDOMTest = callbacks[0]
+      @DOM::onFooterTest = callbacks[1]
+
+      dom = new @DOM
+      dom.__assignElements()
+      dom.__delegateEvents()
+
+      dom.$container.trigger 'test'
+      $('.footer', dom.$container).trigger 'test'
+      $('.post', dom.$container).trigger 'test'
+
+      expect(callbacks[0].callCount).toEqual 5
+      expect(callbacks[1].callCount).toEqual 1
+      expect(callbacks[2].callCount).toEqual 3

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

@@ -40,11 +40,6 @@ describe "Joosy.Modules.Events", ->
 
         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", ->
@@ -75,10 +70,22 @@ describe "Joosy.Modules.Events", ->
 
         expect(@callback.callCount).toEqual 0
 
-      it "recognizes invalid arguments", ->
-        expect(=> @eventer.bind '', @callback).toThrow()
-        expect(=> @eventer.bind '    ', @callback).toThrow()
-        expect(=> @eventer.bind [], @callback).toThrow()
+    describe 'remember', ->
+
+      it 'binds', ->
+        @eventer.trigger name: 'e1', remember: true
+        @eventer.bind 'e1 e2', @callback
+        @eventer.trigger 'e1', @callback
+        @eventer.trigger 'e2', @callback
+
+        expect(@callback.callCount).toEqual 1
+
+      it 'waits', ->
+        @eventer.trigger name: 'e1', remember: true
+        @eventer.wait 'e1 e2', @callback
+        @eventer.trigger 'e2', @callback
+
+        expect(@callback.callCount).toEqual 1
 
     it "allows simultaneous usage", ->
       3.times (i) => @eventer.bind "event#{i}", @callback

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

@@ -1,91 +1,234 @@
 describe "Joosy.Modules.Filters", ->
 
-  beforeEach ->
-    class @Filters extends Joosy.Module
-      @include Joosy.Modules.Filters
-
-    @filters = new @Filters
-
-  it "inherits filters by copying them", ->
-    class A extends @Filters
-      @beforeLoad 'filter1'
-      @afterLoad 'filter2'
-      @afterUnload 'filter3'
-
-    class B extends A
-      @beforeLoad 'filter4'
-      @afterLoad 'filter5'
-      @afterUnload 'filter6'
-
-    target = new B
-    expect(target.__beforeLoads).toEqual ['filter1', 'filter4']
-    expect(target.__afterLoads).toEqual ['filter2', 'filter5']
-    expect(target.__afterUnloads).toEqual ['filter3', 'filter6']
-
-    target = new A
-    expect(target.__beforeLoads).toEqual ['filter1']
-    expect(target.__afterLoads).toEqual ['filter2']
-    expect(target.__afterUnloads).toEqual ['filter3']
-
-    target = new @Filters
-    expect(target.__beforeLoads).toBeUndefined()
-    expect(target.__afterLoads).toBeUndefined()
-    expect(target.__afterUnloads).toBeUndefined()
-
-  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(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)
+  describe 'plain', ->
+
+    beforeEach ->
+      class @Filters extends Joosy.Module
+        @include Joosy.Modules.Filters
+        @registerPlainFilters 'beforeLoad', 'afterLoad', 'afterUnload'
+
+      @filters = new @Filters
+
+    it "inherits filters by copying them", ->
+      class A extends @Filters
+        @beforeLoad 'filter1'
+        @afterLoad 'filter2'
+        @afterUnload 'filter3'
+
+      class B extends A
+        @beforeLoad 'filter4'
+        @afterLoad 'filter5'
+        @afterUnload 'filter6'
+
+      target = new B
+      expect(target.__beforeLoads).toEqual ['filter1', 'filter4']
+      expect(target.__afterLoads).toEqual ['filter2', 'filter5']
+      expect(target.__afterUnloads).toEqual ['filter3', 'filter6']
+
+      target = new A
+      expect(target.__beforeLoads).toEqual ['filter1']
+      expect(target.__afterLoads).toEqual ['filter2']
+      expect(target.__afterUnloads).toEqual ['filter3']
+
+      target = new @Filters
+      expect(target.__beforeLoads).toBeUndefined()
+      expect(target.__afterLoads).toBeUndefined()
+      expect(target.__afterUnloads).toBeUndefined()
+
+    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(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)
+
+  describe 'sequenced', ->
+
+    beforeEach ->
+      class @Filters extends Joosy.Module
+        @include Joosy.Modules.Filters
+        @registerSequencedFilters 'beforeLoad', 'afterLoad', 'afterUnload'
+
+      @filters = new @Filters
+
+    it "inherits filters by copying them", ->
+      class A extends @Filters
+        @beforeLoad 'filter1'
+        @afterLoad 'filter2'
+        @afterUnload 'filter3'
+
+      class B extends A
+        @beforeLoad 'filter4'
+        @afterLoad 'filter5'
+        @afterUnload 'filter6'
+
+      target = new B
+      expect(target.__beforeLoads).toEqual ['filter1', 'filter4']
+      expect(target.__afterLoads).toEqual ['filter2', 'filter5']
+      expect(target.__afterUnloads).toEqual ['filter3', 'filter6']
+
+      target = new A
+      expect(target.__beforeLoads).toEqual ['filter1']
+      expect(target.__afterLoads).toEqual ['filter2']
+      expect(target.__afterUnloads).toEqual ['filter3']
+
+      target = new @Filters
+      expect(target.__beforeLoads).toBeUndefined()
+      expect(target.__afterLoads).toBeUndefined()
+      expect(target.__afterUnloads).toBeUndefined()
+
+    it "runs with no callbacks", ->
+      spy = sinon.spy()
+
+      @filters.__runBeforeLoads [], =>
+        @filters.__runAfterLoads ['test'], =>
+          @filters.__runAfterUnloads ['test'], =>
+            spy()
+
+      expect(spy.callCount).toEqual 1
+
+    it "runs single callbacks", ->
+      spy = sinon.spy()
+      context = @filters
+
+      @Filters.beforeLoad (complete) ->
+        expect(@).toEqual context
+        spy(); complete()
+      @Filters.afterLoad (argument, complete) ->
+        expect(@).toEqual context
+        spy(argument); complete()
+      @Filters.afterUnload (argument1, argument2, complete) ->
+        expect(@).toEqual context
+        spy(argument1, argument2); complete()
+
+      @filters.__runBeforeLoads [], =>
+        expect(spy.callCount).toEqual 1
+
+        @filters.__runAfterLoads ['test'], =>
+          expect(spy.callCount).toEqual 2
+          expect(spy.args[1][0]).toEqual 'test'
+
+          @filters.__runAfterUnloads ['test', 'test2'], =>
+            expect(spy.callCount).toEqual 3
+            expect(spy.args[2][0]).toEqual 'test'
+            expect(spy.args[2][1]).toEqual 'test2'
+
+    it "runs multiple callbacks", ->
+      spies = 0.upto(2).map -> sinon.spy()
+      context = @filters
+
+      @Filters.beforeLoad (argument, complete) ->
+        expect(argument).toEqual 'test'
+        expect(@).toEqual context
+        spies[0]()
+        complete()
+
+      @Filters.beforeLoad (argument, complete) ->
+        expect(argument).toEqual 'test'
+        expect(@).toEqual context
+        spies[1]()
+        complete()
+
+      @Filters.beforeLoad (argument, complete) ->
+        expect(argument).toEqual 'test'
+        expect(@).toEqual context
+        spies[2]()
+        complete()
+
+      @filters.__runBeforeLoads ['test'], ->
+        expect(spies).toBeSequenced()
+
+    # 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

@@ -15,9 +15,9 @@ describe "Joosy.Modules.Log", ->
     expect(@stub.callCount).toEqual 1
 
   it "should log debug messages into console", ->
-    Joosy.Application.config.debug = true
+    Joosy.debug(true)
     @logger.debug 'debug message'
-    Joosy.Application.config.debug = false
+    Joosy.debug(false)
     @logger.debug 'unseen debug message'
 
     expect(@stub.callCount).toEqual 1

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

@@ -26,13 +26,17 @@ describe "Joosy.Modules.Renderer", ->
     it "accepts lambda", ->
       expect(@renderer.render @template, foo: 'bar').toEqual 'result'
 
+    it "expects templater definition", ->
+      expect(=> @renderer.render 'template', foo: 'bar').toThrow()
+
     it "accepts template", ->
-      target = sinon.stub Joosy.Application.templater, 'buildView'
-      target.returns @template
+      Joosy.templater
+        buildView: ->
+          -> 'result'
 
-      expect(@renderer.render @template, foo: 'bar').toEqual 'result'
+      expect(@renderer.render 'template', foo: 'bar').toEqual 'result'
 
-      Joosy.Application.templater.buildView.restore()
+      Joosy.templater false
 
   describe "dynamic rendering", ->
     beforeEach ->