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

data/spec/joosy/core/page_spec.coffee

@@ -1,178 +1,242 @@
 describe "Joosy.Page", ->
 
-  beforeEach ->
-    window.JST = 'app/templates/layouts/default': (->)
-    class window.ApplicationLayout extends Joosy.Layout
-    class @TestPage extends Joosy.Page
+  describe "manager", ->
 
+    beforeEach ->
+      @Layout = class Layout extends Joosy.Layout
 
-  describe "not rendered page", ->
+      class @Page extends Joosy.Page
+        @layout Layout
 
-    beforeEach ->
-      sinon.stub @TestPage.prototype, '__bootstrap'
-      sinon.stub @TestPage.prototype, '__bootstrapLayout'
-      @box = new @TestPage()
-      expect(@TestPage::__bootstrap.callCount).toEqual 0
-      expect(@TestPage::__bootstrapLayout.callCount).toEqual 1
-
-
-    it "should have appropriate accessors", ->
-      callback_names = ['beforePaint', 'paint', 'afterPaint', 'erase']
-      callback_names.each (func) =>
-        @TestPage[func] 'callback'
-        expect(@TestPage::['__' + func]).toEqual 'callback'
-
-      @TestPage.scroll '#here'
-      expect(@TestPage::__scrollElement).toEqual '#here'
-      expect(@TestPage::__scrollSpeed).toEqual 500
-      expect(@TestPage::__scrollMargin).toEqual 0
-
-      @TestPage.scroll '#there', speed: 1000, margin: -5
-      expect(@TestPage::__scrollElement).toEqual '#there'
-      expect(@TestPage::__scrollSpeed).toEqual 1000
-      expect(@TestPage::__scrollMargin).toEqual -5
-
-      @TestPage.layout 'test'
-      expect(@TestPage::__layoutClass).toEqual 'test'
-
-    it "should not render layout if it not changes", ->
-      @box.layout = new ApplicationLayout()
-      @box.layout.yield()
-      new @TestPage {}, @box
-      expect(@TestPage::__bootstrap.callCount).toEqual 1
-      expect(@TestPage::__bootstrapLayout.callCount).toEqual 1
-
-    it "should render layout if it changes", ->
-      class SubLayout extends Joosy.Layout
-      @box = new @TestPage()
-      new @TestPage {}, @box
-      expect(@TestPage::__bootstrap.callCount).toEqual 0
-      expect(@TestPage::__bootstrapLayout.callCount).toEqual 3
-
-    it "should stop render on beforeFilter result", ->
-      sinon.stub @TestPage.prototype, '__runBeforeLoads'
-      @TestPage::__runBeforeLoads.returns(false)
-      new @TestPage()
-      expect(@TestPage::__bootstrap.callCount).toEqual 0
-      expect(@TestPage::__bootstrapLayout.callCount).toEqual 1
-
-    it "should use Router", ->
+      sinon.stub @Page.prototype, '__bootstrap'
+      sinon.stub @Page.prototype, '__bootstrapLayout'
+
+    afterEach ->
+      @Page::__bootstrap.restore()
+      @Page::__bootstrapLayout.restore()
+
+    it "has appropriate accessors", ->
+      callbackNames = ['beforePaint', 'paint', 'afterPaint', 'erase']
+      callbackNames.each (callbackName) =>
+        @Page[callbackName] 'callback'
+        expect(@Page::['__' + callbackName]).toEqual 'callback'
+
+      @Page.scroll '#here'
+      expect(@Page::__scrollElement).toEqual '#here'
+      expect(@Page::__scrollSpeed).toEqual 500
+      expect(@Page::__scrollMargin).toEqual 0
+
+      @Page.scroll '#there', speed: 1000, margin: -5
+      expect(@Page::__scrollElement).toEqual '#there'
+      expect(@Page::__scrollSpeed).toEqual 1000
+      expect(@Page::__scrollMargin).toEqual -5
+
+      @Page.layout 'test'
+      expect(@Page::__layoutClass).toEqual 'test'
+
+    it "integrates with Router", ->
       target = sinon.stub Joosy.Router, 'navigate'
-      @box.navigate 'there'
+      (new @Page).navigate 'there'
       expect(target.callCount).toEqual 1
       expect(target.alwaysCalledWithExactly 'there').toBeTruthy()
       Joosy.Router.navigate.restore()
 
-    it "should load itself", ->
+    it "respects beforeFilters cancelation", ->
+      sinon.stub @Page.prototype, '__runBeforeLoads'
+      @Page::__runBeforeLoads.returns(false)
+
+      new @Page
+
+      expect(@Page::__bootstrap.callCount).toEqual 0
+      expect(@Page::__bootstrapLayout.callCount).toEqual 0
+
+    describe "layout switcher", ->
+
+      beforeEach ->
+        @page = new @Page
+        @page.layout = new @Layout
+
+      it "does not render when previous layout is the same", ->
+        new @Page {}, @page
+
+        expect(@Page::__bootstrap.callCount).toEqual 1
+        expect(@Page::__bootstrapLayout.callCount).toEqual 1
+
+      it "renders when previous layout is another class", ->
+        class Layout extends Joosy.Layout
+        class Page extends Joosy.Page
+          @layout Layout
+
+        sinon.stub Page.prototype, '__bootstrap'
+        sinon.stub Page.prototype, '__bootstrapLayout'
+
+        new Page {}, @page
+
+        expect(@Page::__bootstrap.callCount).toEqual 0
+        expect(@Page::__bootstrapLayout.callCount).toEqual 1
+        expect(Page::__bootstrap.callCount).toEqual 0
+        expect(Page::__bootstrapLayout.callCount).toEqual 1
+
+    it "loads", ->
+      page = new @Page
+
       spies = []
-      spies.push sinon.spy(@box, '__assignElements')
-      spies.push sinon.spy(@box, '__delegateEvents')
-      spies.push sinon.spy(@box, '__setupWidgets')
-      spies.push sinon.spy(@box, '__runAfterLoads')
-      @box.__load()
+      spies.push sinon.spy(page, '__assignElements')
+      spies.push sinon.spy(page, '__delegateEvents')
+      spies.push sinon.spy(page, '__setupWidgets')
+      spies.push sinon.spy(page, '__runAfterLoads')
+      page.__load()
       expect(spies).toBeSequenced()
 
-    it "should unload itself", ->
+    it "unloads", ->
+      page = new @Page
+
       spies = []
-      spies.push sinon.spy(@box, '__clearTime')
-      spies.push sinon.spy(@box, '__unloadWidgets')
-      spies.push sinon.spy(@box, '__removeMetamorphs')
-      spies.push sinon.spy(@box, '__runAfterUnloads')
-      @box.__unload()
+      spies.push sinon.spy(page, '__clearTime')
+      spies.push sinon.spy(page, '__unloadWidgets')
+      spies.push sinon.spy(page, '__removeMetamorphs')
+      spies.push sinon.spy(page, '__runAfterUnloads')
+      page.__unload()
       expect(spies).toBeSequenced()
 
-    describe "rendered page", ->
+  describe "rendering", ->
 
-      beforeEach ->
-        @box.previous = new @TestPage()
-        @box.previous.layout = new @box.previous.__layoutClass
-        @box.__renderer = sinon.spy()
-        @box.__layoutClass.prototype.__renderer = sinon.spy()
-        @TestPage::__bootstrap.restore()
-        @TestPage::__bootstrapLayout.restore()
+    beforeEach ->
+      # Layouts inject themselves into `Joosy.Application.content`
+      # so let's make them inject where we want
+      sinon.stub Joosy.Application, 'content'
+      Joosy.Application.content.returns @$ground
 
+      # We test every module separately so there's no need to run all those
+      sinon.stub Joosy.Page.prototype, '__load'
+      sinon.stub Joosy.Page.prototype, '__unload'
+      sinon.stub Joosy.Layout.prototype, '__load'
+      sinon.stub Joosy.Layout.prototype, '__unload'
 
-      it "should wait stageClear and dataReceived event to start render", ->
-        spies = []
+    afterEach ->
+      Joosy.Application.content.restore()
+      Joosy.Page::__load.restore()
+      Joosy.Page::__unload.restore()
+      Joosy.Layout::__load.restore()
+      Joosy.Layout::__unload.restore()
 
-        spies.push @box.previous.__erase = sinon.spy (stage, callback) ->
-          expect(stage.selector).toEqual @layout.content().selector
-          callback()
+    it "renders", ->
+      class Layout extends Joosy.Layout
+        @view (locals) -> locals.page 'div', class: 'layout'
 
-        spies.push sinon.spy(@box.previous, '__unload')
+      class Page extends Joosy.Page
+        @layout Layout
+        @view (locals) -> 'page'
 
-        spies.push @box.__beforePaint = sinon.spy (stage, callback) ->
-          expect(stage.selector).toEqual @layout.content().selector
-          expect(@__oneShotEvents[0][0]).toEqual ['stageClear', 'dataReceived']
-          callback()
-          expect(@__oneShotEvents[0][0]).toEqual ['dataReceived']
+      page = new Page
+      expect(@$ground.html()).toMatch /<div class\=\"layout\" id=\"__joosy\d+\">page<\/div>/
 
-        spies.push @box.__fetch = sinon.spy (callback) ->
-          expect(@__oneShotEvents[0][0]).toEqual ['dataReceived']
-          callback()
-          expect(@__oneShotEvents).toEqual {}
+    it "changes page", ->
+      class Layout extends Joosy.Layout
+        @view (locals) -> locals.page 'div'
 
-        spies.push @box.__paint = sinon.spy (stage, callback) ->
-          expect(stage.selector).toEqual @layout.content().selector
-          expect(typeof callback).toEqual 'function'
-          # callback()  - start rendering
+      class PageA extends Joosy.Page
+        @layout Layout
+        @view (locals) -> 'page a'
 
-        @box.__bootstrap()
+      class PageB extends Joosy.Page
+        @layout Layout
+        @view (locals) -> 'page b'
 
-        expect(spies).toBeSequenced()
+      page = new PageA
+      expect(@$ground.html()).toMatch /<div id=\"__joosy\d+\">page a<\/div>/
 
-      it "should render page", ->
-        spies = []
+      page = new PageB {}, page
+      expect(@$ground.html()).toMatch /<div id=\"__joosy\d+\">page b<\/div>/
 
-        spies.push @box.__renderer
-        spies.push sinon.spy(@box, 'swapContainer')
-        spies.push sinon.spy(@box, '__load')
+    it "changes layout", ->
+      class LayoutA extends Joosy.Layout
+        @view (locals) -> locals.page 'div'
 
-        @box.__bootstrap()
-        expect(spies).toBeSequenced()
+      class PageA extends Joosy.Page
+        @layout LayoutA
+        @view (locals) -> ''
 
-      it "should wait stageClear and dataReceived event to start layout render", ->
-        spies = []
+      class LayoutB extends Joosy.Layout
+        @view (locals) -> locals.page 'div'
 
-        spies.push ApplicationLayout::__erase = sinon.spy (stage, page, callback) ->
-          expect(stage.selector).toEqual Joosy.Application.content().selector
-          callback()
+      class PageB extends Joosy.Page
+        @layout LayoutB
+        @view (locals) -> ''
 
-        spies.push sinon.spy(@box.previous.layout, '__unload')
-        spies.push sinon.spy(@box.previous, '__unload')
+      page = new PageA
+      html = @$ground.html()
+      expect(html).toMatch /<div id=\"__joosy\d+\"><\/div>/
 
-        spies.push ApplicationLayout::__beforePaint = sinon.spy (stage, page, callback) =>
-          expect(stage.selector).toEqual Joosy.Application.content().selector
-          expect(@box.__oneShotEvents[0][0]).toEqual ['stageClear', 'dataReceived']
-          callback()
-          expect(@box.__oneShotEvents[0][0]).toEqual ['dataReceived']
+      page = new PageB {}, page
+      expect(@$ground.html()).toMatch /<div id=\"__joosy\d+\"><\/div>/
+      expect(@$ground.html()).not.toEqual html
 
-        spies.push @box.__fetch = sinon.spy (callback) ->
-          expect(@__oneShotEvents[0][0]).toEqual ['dataReceived']
-          callback()
-          expect(@__oneShotEvents).toEqual {}
+    it "proxies @params to layout", ->
+      class Layout extends Joosy.Layout
+        @view (locals) -> locals.page 'div', class: 'layout'
 
-        spies.push ApplicationLayout::__paint = sinon.spy (stage, page, callback) ->
-          expect(stage.selector).toEqual Joosy.Application.content().selector
-          expect(typeof callback).toEqual 'function'
-          # callback()  - start rendering
+        constructor: (@params) ->
+          expect(@params).toEqual foo: 'bar'
+          super
 
-        @box.__bootstrapLayout()
+      class Page extends Joosy.Page
+        @layout Layout
+        @view (locals) -> 'page'
 
-        expect(spies).toBeSequenced()
+      page = new Page foo: 'bar'
 
-      it "should render layout and page", ->
-        spies = []
+    it "passes @data to @view", ->
+      class Layout extends Joosy.Layout
+        @fetch (complete) ->
+          expect(@data).toEqual {}
+          @data.foo = 'bar'
+          complete()
 
-        @box.params = {tested: true}
+        @view (locals) ->
+          expect(locals.foo).toEqual 'bar'
 
-        spies.push @box.__layoutClass.prototype.__renderer
-        spies.push @box.__renderer
-        swapContainer = sinon.spy(@box, 'swapContainer')
-        spies.push @box.__layoutClass.prototype.__load = sinon.spy()
-        spies.push sinon.spy(@box, '__load')
+      class Page extends Joosy.Page
+        @layout Layout
+
+        @fetch (complete) ->
+          expect(@data).toEqual {}
+          @data.foo = 'bar'
+          complete()
+
+        @view (locals) ->
+          expect(locals.foo).toEqual 'bar'
+
+      page = new Page
+
+    it "hooks", ->
+      spies = []
+      11.times -> spies.push sinon.spy()
 
-        @box.__bootstrapLayout()
-        expect(spies).toBeSequenced()
-        expect(swapContainer.callCount).toEqual 2
-        expect(@box.layout.params).toEqual {tested: true}
+      class Layout extends Joosy.Layout
+        @beforePaint (container, page, complete) -> spies[0](); complete()
+        @fetch       (complete)                  -> spies[1](); complete()
+        @paint       (container, page, complete) -> spies[3](); complete()
+
+        @view spies[4]
+
+      class PageA extends Joosy.Page
+        @layout Layout
+
+        @fetch       (complete)            -> spies[2](); complete()
+        @erase       (container, complete) -> spies[6](); complete()
+        @view spies[5]
+
+      class PageB extends Joosy.Page
+        @layout Layout
+
+        @beforePaint (container, complete) -> spies[7](); complete()
+        @fetch       (complete)            -> spies[8](); complete()
+        @paint       (container, complete) -> spies[9](); complete()
+
+        @view spies[10]
+
+      page = new PageA
+      page = new PageB {}, page
+
+      expect(spies).toBeSequenced()

data/spec/joosy/core/templaters/jst_spec.coffee

@@ -0,0 +1,62 @@
+describe "Joosy.Templaters.JST", ->
+
+  describe "builder", ->
+
+    beforeEach ->
+      window.JST = {}
+      window.I18n = {locale: 'en'}
+
+    afterEach ->
+      delete window.JST
+      delete window.I18n
+
+    describe "with empty application name", ->
+
+      beforeEach ->
+        @templater = new Joosy.Templaters.JST
+
+      it "resolves plain template", ->
+        JST['templates/test'] = 'template'
+        expect(@templater.buildView('test')).toEqual 'template'
+
+      it "preffers localized template", ->
+        JST['templates/test'] = 'error'
+        JST['templates/test-en'] = 'template'
+        expect(@templater.buildView('test')).toEqual 'template'
+
+    describe "with set application name", ->
+
+      beforeEach ->
+        @templater = new Joosy.Templaters.JST('application')
+
+      it "resolves plain template", ->
+        JST['application/templates/test'] = 'template'
+        expect(@templater.buildView('test')).toEqual 'template'
+
+      it "preffers localized template", ->
+        JST['application/templates/test'] = 'error'
+        JST['application/templates/test-en'] = 'template'
+        expect(@templater.buildView('test')).toEqual 'template'
+
+  it "resolves templates correctly", ->
+    templater = new Joosy.Templaters.JST
+
+    class Klass extends Joosy.Module
+
+    Joosy.namespace 'British.Cities', ->
+      class @Klass extends Joosy.Module
+
+    expect(templater.resolveTemplate(undefined, "/absolute", undefined)).
+      toEqual "absolute"
+
+    expect(templater.resolveTemplate('widgets', 'fuga', {})).
+      toEqual 'widgets/fuga'
+
+    expect(templater.resolveTemplate('widgets', 'fuga', new Klass)).
+      toEqual 'widgets/fuga'
+
+    expect(templater.resolveTemplate('widgets', 'fuga', new British.Cities.Klass)).
+      toEqual 'widgets/british/cities/fuga'
+
+    expect(templater.resolveTemplate('widgets', 'hoge/fuga', new British.Cities.Klass)).
+      toEqual 'widgets/british/cities/hoge/fuga'

data/spec/joosy/core/widget_spec.coffee

@@ -1,40 +1,36 @@
 describe "Joosy.Widget", ->
 
   beforeEach ->
-    class @TestWidget extends Joosy.Widget
-    @box = new @TestWidget()
+    class @Widget extends Joosy.Widget
+    @widget = new @Widget
 
-  it "should have appropriate accessors", ->
-    test = ->
-    @TestWidget.view test
-    expect(@TestWidget::__renderer).toEqual test
-    @TestWidget.view 'test'
-    expect(@TestWidget::__renderer instanceof Function).toBeTruthy()
-
-  it "should use Router", ->
+  it "integrates with Router", ->
     target = sinon.stub Joosy.Router, 'navigate'
-    @box.navigate 'there'
+    @widget.navigate 'there'
     expect(target.callCount).toEqual 1
     expect(target.alwaysCalledWithExactly 'there').toBeTruthy()
     Joosy.Router.navigate.restore()
 
-  it "should load itself", ->
-    @box.data = {tested: true}
-    spies = [sinon.spy()]
-    @TestWidget.view spies[0]
-    @parent = new Joosy.Layout()
-    spies.push sinon.spy(@box, '__assignElements')
-    spies.push sinon.spy(@box, '__delegateEvents')
-    spies.push sinon.spy(@box, '__runAfterLoads')
-    target = @box.__load @parent, @ground
-    expect(target).toBe @box
-    expect(@box.__renderer.getCall(0).calledOn()).toBeFalsy()
-    expect(@box.__renderer.getCall(0).args[0]).toEqual {tested: true}
+  it "loads", ->
+    spies = []
+    spies.push sinon.spy()
+    spies.push sinon.spy(@widget, '__assignElements')
+    spies.push sinon.spy(@widget, '__delegateEvents')
+    spies.push sinon.spy(@widget, '__runAfterLoads')
+
+    @widget.data = tested: true
+    @Widget.view spies[0]
+    @parent = new Joosy.Layout
+
+    target = @widget.__load @parent, @$ground
+
+    expect(target).toBe @widget
+    expect(spies[0].getCall(0).calledOn()).toBeFalsy()
+    expect(spies[0].getCall(0).args[0].tested).toBe true
     expect(spies).toBeSequenced()
 
-  it "should unload itself", ->
-    sinon.spy @box, '__runAfterUnloads'
-    @box.__unload()
-    target = @box.__runAfterUnloads
-    expect(target.callCount).toEqual 1
-    expect(target.getCall(0).calledOn()).toBeFalsy()
+  it "unloads", ->
+    sinon.spy @widget, '__runAfterUnloads'
+    @widget.__unload()
+    expect(@widget.__runAfterUnloads.callCount).toEqual 1
+    expect(@widget.__runAfterUnloads.getCall(0).calledOn()).toBeFalsy()

data/spec/joosy/extensions/form/form_spec.coffee

@@ -1,6 +1,8 @@
 describe "Joosy.Form", ->
 
   beforeEach ->
+    Joosy.Resources.Base?.resetIdentity()
+
     @server = sinon.fakeServer.create()
     @seedGround()
     @nudeForm = "<form id='nude'><input name='test[foo]'/><input name='test[bar]'/><input name='test[bool]' type='checkbox' value='1'/><input name='test[set]' type='radio' value='qwe' /><input name='test[set]' type='radio' value='zxc' /></form>"
@@ -10,7 +12,7 @@ describe "Joosy.Form", ->
     @exactForm = "<form id='exact'><input name='test[EXact][MATCH]'/></form>"
     @arrayForm = "<form id='array'><input name='test[arr][1][0][1]'/></form>"
 
-    @ground.find('#sidebar').after(@nudeForm).after(@putForm).after(@moreForm).after(@nestedForm).after(@exactForm).after(@arrayForm)
+    @$ground.find('#sidebar').after(@nudeForm).after(@putForm).after(@moreForm).after(@nestedForm).after(@exactForm).after(@arrayForm)
 
     @nudeForm = $('#nude')
     @putForm  = $('#put')

data/spec/joosy/extensions/resources/base_spec.coffee

@@ -1,5 +1,8 @@
 describe "Joosy.Resources.Base", ->
 
+  beforeEach ->
+    Joosy.Resources.Base?.resetIdentity()
+
   class TestInline extends Joosy.Resources.Base
     @entity 'test_inline'
 

data/spec/joosy/extensions/resources/collection_spec.coffee

@@ -1,5 +1,8 @@
 describe "Joosy.Resources.Collection", ->
 
+  beforeEach ->
+    Joosy.Resources.Base?.resetIdentity()
+
   class Test extends Joosy.Resources.Base
     @entity 'test'
 

data/spec/joosy/extensions/resources/rest_collection_spec.coffee

@@ -1,5 +1,8 @@
 describe "Joosy.Resources.RESTCollection", ->
 
+  beforeEach ->
+    Joosy.Resources.Base?.resetIdentity()
+
   class Test extends Joosy.Resources.REST
     @entity 'test'
 

data/spec/joosy/extensions/resources/rest_spec.coffee

@@ -1,5 +1,8 @@
 describe "Joosy.Resources.REST", ->
 
+  beforeEach ->
+    Joosy.Resources.Base?.resetIdentity()
+
   class FluffyInline extends Joosy.Resources.REST
     @entity 'fluffy_inline'
 

data/src/joosy/core/application.coffee

@@ -31,7 +31,7 @@ Joosy.Application =
     @mergeConfig(window.JoosyEnvironment) if window.JoosyEnvironment?
     @mergeConfig(options)
 
-    @templater = new Joosy.Templaters.RailsJST @name
+    @templater = new Joosy.Templaters.JST @name
 
     Joosy.Router.__setupRoutes()
 
@@ -41,12 +41,6 @@ Joosy.Application =
   content: ->
     $(@selector)
 
-  #
-  # Gets current application sandbox node
-  #
-  sandbox: ->
-    $(@sandboxSelector)
-
   #
   # Switches to given page
   #

data/src/joosy/core/helpers/view.coffee

@@ -5,6 +5,18 @@
 #
 Joosy.helpers 'Application', ->
 
+  #
+  # Generates HTML tag string
+  #
+  # @param [String] name          Tag name
+  # @param [Object] options       Tag attributes
+  # @param [String] content       String content to inject
+  # @param [Function] content     Function that will be evaluated and the result will be taken as a content
+  #
+  # Example
+  #   != @tag 'div', {class: 'foo'}, =>
+  #     != @tag 'hr'
+  #
   @tag = (name, options={}, content='') ->
     content = content() if Object.isFunction(content)
 

data/src/joosy/core/helpers/widgets.coffee

@@ -5,15 +5,25 @@
 #
 Joosy.helpers 'Application', ->
 
-  @widget = (element, widget) ->
-    uuid    = Joosy.uuid()
-    params  = id: uuid
-    parts   = element.split '.'
-    if parts[1]
-      params.class = parts.from(1).join ' '
+  #
+  # Injects widget
+  # 
+  # @param [String] tag             Tag name to use a widget container
+  # @param [Object] options         Tag attributes
+  # @param [Joosy.Widget] widget    Class or instance of {Joosy.Widget} to register
+  # @param [Function] widget        Function returning class or instance of {Joosy.Widget}
+  #
+  # @note Widget instance will be generated on the next asynchronous tick
+  #   so make sure to append resulting string to DOM synchronously
+  #
+  @widget = (tag, options, widget) ->
+    unless widget?
+      widget  = options
+      options = {}
 
-    element = @tag parts[0], params
+    options.id = Joosy.uid()
 
-    @onRefresh -> @registerWidget '#'+uuid, widget
+    @__renderer.setTimeout 0, =>
+      @__renderer.registerWidget($('#'+options.id), widget)
 
-    element
+    @tag tag, options