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

data/spec/joosy/core/router_spec.coffee

@@ -1,238 +1,300 @@
 describe "Joosy.Router", ->
 
-  class TestPage extends Joosy.Page
-
-  spies =
-    root: sinon.spy()
-    section: sinon.spy()
-    wildcard: sinon.spy()
-
-  map =
-    Object.extended
-      '/': spies.root
-      '/page': TestPage
-      '/section':
-        '/page/:id': spies.section
-        '/page2/:more': TestPage
-      404: spies.wildcard
+  pathname = location.pathname
 
   beforeEach ->
-    Joosy.Router.reset()
-    Joosy.Router.prefix = '!'
-
-  afterEach ->
-    $(window).off 'hashchange'
-
-  it "should map", ->
-    Joosy.Router.map map
-    expect(Joosy.Router.rawRoutes).toEqual map
-
-  it "should initialize on setup", ->
-    sinon.stub Joosy.Router, '__prepareRoutes'
-    sinon.stub Joosy.Router, '__respondRoute'
-
-    Joosy.Router.map map
-    Joosy.Router.__setupRoutes()
-    expect(Joosy.Router.__prepareRoutes.callCount).toEqual 1
-    expect(Joosy.Router.__prepareRoutes.args[0][0]).toEqual map
-    expect(Joosy.Router.__respondRoute.callCount).toEqual 1
-    expect(Joosy.Router.__respondRoute.args[0][0]).toEqual location.hash
-    Joosy.Router.__prepareRoutes.restore()
-    Joosy.Router.__respondRoute.restore()
-
-  it "should prepare route", ->
-    route = Joosy.Router.__prepareRoute "/such/a/long/long/url/:with/:plenty/:of/:params", "123"
-
-    expect(route).toEqual Object.extended
-      '^/?such/a/long/long/url/([^/]+)/([^/]+)/([^/]+)/([^/]+)/?$':
-        capture: ['with', 'plenty', 'of', 'params']
-        action: "123"
-
-  it "should cook routes", ->
-    sinon.stub Joosy.Router, '__respondRoute'
-
-    Joosy.Router.map map
-    Joosy.Router.__setupRoutes()
-
-    expect(Joosy.Router.routes).toEqual Object.extended
-      '^/?/?$':
-        capture: []
-        action: spies.root
-      '^/?page/?$':
-        capture: []
-        action: TestPage
-      '^/?section/page/([^/]+)/?$':
-        capture: ['id']
-        action: spies.section
-      '^/?section/page2/([^/]+)/?$':
-        capture: ['more']
-        action: TestPage
-
-    Joosy.Router.__respondRoute.restore()
-
-  it "should get route params", ->
-    route  = Joosy.Router.__prepareRoute "/such/a/long/long/url/:with/:plenty/:of/:params", "123"
-    result = Joosy.Router.__paramsFromRouteMatch ['full regex match here', 1, 2, 3, 4], route.values().first()
-
-    expect(result).toEqual Object.extended
-      'with':   1
-      'plenty': 2
-      'of':     3
-      'params': 4
-
-  it "should build query params", ->
-    result = Joosy.Router.__paramsFromQueryArray ["foo=bar", "bar=baz"]
-
-    expect(result).toEqual Object.extended
-      foo: 'bar'
-      bar: 'baz'
-
-  it "should respond routes", ->
-    sinon.stub Joosy.Router, '__respondRoute'
-    sinon.stub Joosy.Application, 'setCurrentPage'
-
-    Joosy.Router.map map
-    Joosy.Router.__setupRoutes()
-
-    Joosy.Router.__respondRoute.restore()
-
-    Joosy.Router.__respondRoute '/'
-    expect(spies.root.callCount).toEqual 1
-
-    Joosy.Router.__respondRoute '#/'
-    expect(spies.root.callCount).toEqual 2
-
-    Joosy.Router.__respondRoute '/page'
-    expect(Joosy.Application.setCurrentPage.callCount).toEqual 1
-    expect(Joosy.Application.setCurrentPage.args.last()).toEqual [TestPage, Object.extended()]
-
-    Joosy.Router.__respondRoute '/section/page/1'
-    expect(spies.section.callCount).toEqual 1
-    expect(spies.section.args.last()).toEqual [Object.extended(id: '1')]
-
-    Joosy.Router.__respondRoute '/section/page2/1&a=b'
-    expect(Joosy.Application.setCurrentPage.callCount).toEqual 2
-    expect(Joosy.Application.setCurrentPage.args.last()).toEqual [TestPage, Object.extended(more: '1', a: 'b')]
-
-    Joosy.Router.__respondRoute '/thiswillneverbefound&a=b'
-    expect(spies.wildcard.callCount).toEqual 1
-    expect(spies.wildcard.args.last()).toEqual ['/thiswillneverbefound', Object.extended(a: 'b')]
-
-    Joosy.Application.setCurrentPage.restore()
-
-  it "should navigate", ->
-    Joosy.Router.navigate 'test'
-    expect(location.hash).toEqual "#!test"
-    Joosy.Router.navigate ''
-    expect(location.hash).toEqual '#!'
-
-  it "should restrict urls", ->
-    sinon.stub Joosy.Router, '__respondRoute'
-    sinon.stub Joosy.Application, 'setCurrentPage'
-
-    Joosy.Router.map map
-    Joosy.Router.__setupRoutes()
-
-    Joosy.Router.__respondRoute.restore()
-
-    Joosy.Router.restrict /^\/page$/
-
-    Joosy.Router.__respondRoute '/page'
-    Joosy.Router.__respondRoute '/section/page/1'
-
-    expect(Joosy.Application.setCurrentPage.callCount).toEqual 1
-    expect(Joosy.Application.setCurrentPage.args.last()).toEqual [TestPage, Object.extended()]
-
-    Joosy.Application.setCurrentPage.restore()
-    Joosy.Router.restrict false
-    
-  it "should DRAW simple routes, only using match and root", ->
-    Joosy.Router.map
-      '/': spies.root
-      '/page': TestPage
-      404: spies.wildcard
-    raw_routes_for_map = Joosy.Router.rawRoutes
-
-    Joosy.Router.reset()
-    
-    Joosy.Router.draw ->
-      @root to: spies.root
-      @match '/page', to: TestPage
-      @notFound to: spies.wildcard
-      
-    expect(Joosy.Router.rawRoutes).toEqual(raw_routes_for_map)
-    
-  it "should DRAW namespaced routes", ->
-    Joosy.Router.map
-      '/': spies.root
-      '/page': TestPage
+    class @Page extends Joosy.Page
+
+    @spies =
+      responder: sinon.spy()
+      root: sinon.spy()
+      base: sinon.spy()
+      section: sinon.spy()
+      wildcard: sinon.spy()
+
+    @map =
+      '/': @spies.root
+      '/base': @spies.base
+      'page': @Page
       '/section':
-        '/page/:id': spies.section
-        '/page2/:more': TestPage
-      404: spies.wildcard
-    rawRoutesForMap = Joosy.Router.rawRoutes
-
-    Joosy.Router.reset()
-    
-    Joosy.Router.draw ->
-      @root to: spies.root
-      @match '/page', to: TestPage
-      @namespace '/section', ->
-        @match '/page/:id', to: spies.section
-        @match '/page2/:more', to: TestPage
-      @notFound to: spies.wildcard
-      
-    expect(Joosy.Router.rawRoutes).toEqual(rawRoutesForMap)
-    
-  it "should DRAW simple route reverses, only using match and root", ->
-    Joosy.Router.draw ->
-      @root to: spies.root
-      @match '/page', to: TestPage, as: "page"
-      @match '/page/:id', to: TestPage, as: "pageFor"
-      @notFound to: spies.wildcard
-      
-    validate = ->
-      expect(@rootUrl).not.toEqual undefined
-      expect(@rootPath).not.toEqual undefined
-    
-      expect(@rootPath()).toEqual "#!/"
-      expect(@pagePath()).toEqual "#!/page"
-      expect(@pageForPath(id: 3)).toEqual "#!/page/3"
-    validate.call(Joosy.Helpers.Application)
-    
-  it "should DRAW more complex reverses using namespaces", ->
-    Joosy.Router.draw ->
-      @namespace '/projects', as: "projects", ->
-        @match "/", to: TestPage, as: "index"
-        @namespace "/:id", ->
-          @match "/", to: TestPage, as: "show"
-          @match "/edit", to: TestPage, as: "edit"
-          @match "/delete", to: TestPage, as: "delete"
-          
-      @namespace '/tickets', ->
-        @match "/", to: TestPage, as: "tasksIndex"
-        
-      @namespace '/activities', ->
-        @root to: TestPage, as: "activities"
-
-    validate = ->
-      expect(@projectsIndexPath).not.toEqual undefined
-      expect(@projectsIndexPath()).not.toEqual "#!/projects"
-      expect(@projectsIndexPath()).toEqual "#!/projects/"
-    
-      expect(@projectsShowPath(id: 3)).toEqual "#!/projects/3/"
-      expect(@projectsEditPath(id: 3)).toEqual "#!/projects/3/edit"
-      expect(@projectsDeletePath(id: 3)).toEqual "#!/projects/3/delete"
-    
-      expect(@tasksIndexPath()).toEqual "#!/tickets/"
-      expect(@activitiesPath()).toEqual "#!/activities/"
-    validate.call(Joosy.Helpers.Application)
-    
-  it "should return reverse url with hostname and pathname", ->
-    Joosy.Router.draw ->
-      @match "/projects/", to: TestPage, as: "projectsIndex"
-        
-    validate = ->
-      expect(@projectsIndexPath()).toEqual "#!/projects/"
-      expect(@projectsIndexUrl()).toEqual "#{location.protocol}//#{location.host}#{location.pathname}#!/projects/"
-    validate.call(Joosy.Helpers.Application)
+        '/page/:id': @spies.section
+        'page2/:more': @Page
+      404: @spies.wildcard
+
+  describe 'core', ->
+    afterEach ->
+      Joosy.Router.reset()
+
+    it 'draws', ->
+      spies = @spies
+      Page  = @Page
+
+      Joosy.Router.draw ->
+        @root to: spies.root
+        @match '/base', to: spies.base
+        @match '/page',  to: Page
+        @namespace '/section', {as: 'section'}, ->
+          @match '/page/:id', to: spies.section, as: 'page'
+          @match '/page2/:more', to: Page
+        @notFound to: spies.wildcard
+
+      expect(Joosy.Router.routes).toEqual
+        '^/?/?$':
+          to: spies.root
+          as: 'root'
+          capture: []
+        '^/?base/?$':
+          to: spies.base,
+          capture: [],
+        '^/?page/?$':
+          to: Page, capture : []
+        '^/?section/page/([^/]+)/?$':
+          to: spies.section,
+          as: 'sectionPage'
+          capture: ['id']
+        '^/?section/page2/([^/]+)/?$':
+          to: Page
+          capture: ['more']
+
+      expect(Joosy.Router.wildcardAction).toEqual spies.wildcard
+
+    it 'maps', ->
+      Joosy.Router.map @map
+
+      expect(Joosy.Router.routes).toEqual
+        '^/?/?$':
+          to: @spies.root
+          as: undefined
+          capture: []
+        '^/?base/?$':
+          to: @spies.base
+          as: undefined
+          capture: []
+        '^/?page/?$':
+          to: @Page
+          capture: []
+          as: undefined
+        '^/?section/page/([^/]+)/?$':
+          to: @spies.section
+          as: undefined
+          capture: ['id']
+        '^/?section/page2/([^/]+)/?$':
+          to: @Page
+          capture: ['more']
+          as: undefined
+
+      expect(Joosy.Router.wildcardAction).toEqual @spies.wildcard
+
+    it 'compiles plain route', ->
+      Joosy.Router.compileRoute '/such/a/long/long/url/:with/:plenty/:of/:params', '123'
+
+      expect(Joosy.Router.routes['^/?such/a/long/long/url/([^/]+)/([^/]+)/([^/]+)/([^/]+)/?$']).toEqual
+          capture: ['with', 'plenty', 'of', 'params']
+          to: '123'
+          as: undefined
+
+    it 'compiles aliased route', ->
+      Joosy.Router.compileRoute '/such/a/long/long/url/:with/:plenty/:of/:params', '456', '123'
+
+      expect(Joosy.Router.routes['^/?such/a/long/long/url/([^/]+)/([^/]+)/([^/]+)/([^/]+)/?$']).toEqual
+        capture: ['with', 'plenty', 'of', 'params']
+        to: '456'
+        as: '123'
+
+  describe 'responder', ->
+
+    describe 'hash based', ->
+      beforeEach ->
+        Joosy.Router.setup {html5: false}, @spies.responder, false
+        Joosy.Router.map @map
+
+      afterEach ->
+        Joosy.Router.reset()
+        location.hash = ''
+        waits 0
+
+      it 'resets', ->
+        runs -> Joosy.Router.navigate '/page'
+        waits 0
+        runs ->
+          Joosy.Router.reset()
+          Joosy.Router.navigate '/'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+
+      it 'boots pages', ->
+        runs -> Joosy.Router.navigate '/page'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @Page
+
+      it 'runs lamdas', ->
+        runs -> Joosy.Router.navigate '/base'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.base
+
+      it 'responds namespaced routes', ->
+        runs -> Joosy.Router.navigate '/section/page/1'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.section
+
+      it 'parses query parametrs', ->
+        runs -> Joosy.Router.navigate '/?test=test&foo=bar'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.root
+          expect(@spies.responder.args[0][1]).toEqual {test: 'test', foo: 'bar'}
+
+      it 'parses route placeholders', ->
+        runs -> Joosy.Router.navigate '/section/page/1'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.section
+          expect(@spies.responder.args[0][1]).toEqual {id: '1'}
+
+      it 'ignores restricted routes', ->
+        Joosy.Router.restrict /^base/
+
+        runs -> Joosy.Router.navigate '/base'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 0
+
+      it 'defaults to wildcard route', ->
+        runs -> Joosy.Router.navigate '/trololo'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.wildcard
+
+      it 'navigates', ->
+        runs -> Joosy.Router.navigate '/base'
+        waits 0
+        runs ->
+          location.hash == '#/base'
+          expect(@spies.responder.callCount).toEqual 1
+
+      it 'defines plain helper', ->
+        expect(Joosy.Helpers.Routes.rootPath()).toEqual '#'
+        expect(Joosy.Helpers.Routes.rootUrl()).toEqual "http://localhost:8888#{pathname}#"
+
+      it 'defines namespaced parameterized helpers', ->
+        expect(Joosy.Helpers.Routes.sectionPagePath(id: 1)).toEqual '#section/page/1'
+        expect(Joosy.Helpers.Routes.sectionPageUrl(id: 1)).toEqual "http://localhost:8888#{pathname}#section/page/1"
+
+    describe 'html5 based', ->
+      beforeEach ->
+        Joosy.Router.setup {html5: true}, @spies.responder, false
+        Joosy.Router.map @map
+
+      afterEach ->
+        Joosy.Router.reset()
+        history.pushState {}, '', pathname
+        waits 0
+
+      it 'resets', ->
+        runs -> Joosy.Router.navigate '/page'
+        waits 0
+        runs ->
+          Joosy.Router.reset()
+          Joosy.Router.navigate '/'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+
+      it 'boots pages', ->
+        runs -> Joosy.Router.navigate '/page'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @Page
+
+      it 'runs lamdas', ->
+        runs -> Joosy.Router.navigate '/base'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.base
+
+      it 'responds namespaced routes', ->
+        runs -> Joosy.Router.navigate '/section/page/1'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.section
+
+      it 'parses query parametrs', ->
+        runs -> Joosy.Router.navigate '/?test=test&foo=bar'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.root
+          expect(@spies.responder.args[0][1]).toEqual {test: 'test', foo: 'bar'}
+
+      it 'parses route placeholders', ->
+        runs -> Joosy.Router.navigate '/section/page/1'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.section
+          expect(@spies.responder.args[0][1]).toEqual {id: '1'}
+
+      it 'ignores restricted routes', ->
+        Joosy.Router.restrict /^base/
+
+        runs -> Joosy.Router.navigate '/base'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 0
+
+      it 'defaults to wildcard route', ->
+        runs -> Joosy.Router.navigate '/trololo'
+        waits 0
+        runs ->
+          expect(@spies.responder.callCount).toEqual 1
+          expect(@spies.responder.args[0][0]).toEqual @spies.wildcard
+
+      it 'navigates', ->
+        runs -> Joosy.Router.navigate '/base'
+        waits 0
+        runs ->
+          location.pathname == '/base'
+          expect(@spies.responder.callCount).toEqual 1
+
+      it 'defines plain helper', ->
+        expect(Joosy.Helpers.Routes.rootPath()).toEqual '/'
+        expect(Joosy.Helpers.Routes.rootUrl()).toEqual 'http://localhost:8888/'
+
+      it 'defines namespaced parameterized helpers', ->
+        expect(Joosy.Helpers.Routes.sectionPagePath(id: 1)).toEqual '/section/page/1'
+        expect(Joosy.Helpers.Routes.sectionPageUrl(id: 1)).toEqual 'http://localhost:8888/section/page/1'
+
+  describe 'linker', ->
+    it 'defines helper', ->
+      tag = Joosy.Helpers.Routes.linkTo 'test', '/base', class: 'zomg!'
+
+      expect(tag).toBeTag 'a', 'test',
+        'data-joosy': 'true'
+        href: '/base'
+        class: 'zomg!'
+
+    it 'navigates', ->
+      sinon.stub Joosy.Router, 'navigate'
+
+      @$ground.html """
+                    <a href='#' id='test1'></a>
+                    <a href='#' id='test2' data-joosy='true'></a>
+                    """
+      $('#test1').click()
+      $('#test2').click()
+
+      expect(Joosy.Router.navigate.callCount).toEqual 1
+      Joosy.Router.navigate.restore()

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

@@ -27,7 +27,7 @@ describe "Joosy.Templaters.JST", ->
     describe "with set application name", ->
 
       beforeEach ->
-        @templater = new Joosy.Templaters.JST('application')
+        @templater = new Joosy.Templaters.JST(prefix: 'application')
 
       it "resolves plain template", ->
         JST['application/templates/test'] = 'template'