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

data/package.json

@@ -4,7 +4,7 @@
   "keywords": [
     "joosy"
   ],
-  "version": "1.2.0-alpha.38",
+  "version": "1.2.0-alpha.41",
   "author": "Boris Staal <boris@staal.io>",
   "homepage": "http://joosy.ws/",
   "repository": {
@@ -18,16 +18,16 @@
     "node": ">=0.4.0"
   },
   "dependencies": {
+    "bower": "~1.0.0",
     "sugar": "~1.3.8",
     "coffee-script": "~1.6.3",
     "command-router": "0.0.5",
     "resolve": "~0.4.0",
     "ejs": "~0.8.4",
-    "prompt": "~0.2.9",
+    "commander": "~2.0.0",
     "commander": "~1.2.0",
     "colors": "~0.6.0-1",
     "grunt": "~0.4.1",
-    "bower": "~0.10.0",
     "mincer": "~0.4.6",
     "connect": "~2.7.11",
     "haml-coffee": "~1.11.1",

data/spec/helpers/ground.coffee

@@ -0,0 +1,33 @@
+#
+# DOM builders
+#
+beforeEach ->
+  @$body   = $('body')
+  @$ground = $('<div/>').attr('id', 'ground')
+
+  @$body.append @$ground
+
+  @$ground.seed = @seedGround = =>
+    @$ground.html """
+      <div id="application" class="application">
+        <div id="header" class="header" />
+        <div id="wrapper" class="wrapper">
+          <div id="content" class="content">
+            <div id="post1" class="post" />
+            <div id="post2" class="post" />
+            <div id="post3" class="post" />
+          </div>
+          <div id="sidebar" class="sidebar">
+            <div id="widget1" class="widget" />
+            <div id="widget2" class="widget" />
+          </div>
+        </div>
+        <div id="footer" class="footer" />
+      </div>
+    """
+
+#
+# DOM cleanup
+#
+afterEach ->
+  @$ground.remove()

data/spec/helpers/matchers.coffee

@@ -0,0 +1,65 @@
+beforeEach ->
+  @addMatchers
+
+    #
+    # Checks whether listed array of callbacks was 
+    # called in exact order one by one
+    #
+    # @example
+    #   [ (->), (->), (->) ].toBesequenced()
+    #
+    toBeSequenced: ->
+      # Are we working with array?
+      if !Object.isArray(@actual) || @actual.length == 0
+        @message = -> 'Not array or empty array given'
+        return false
+
+      # Was every spy called just once?
+      for spy, i in @actual
+        unless spy.callCount == 1
+          @message = -> "Spy ##{i} was called #{spy.callCount} times instead of just one"
+          return false
+
+      # Were they called in a proper order?
+      if @actual.length > 1
+        for spy, i in @actual.from(1)
+          unless spy.calledAfter @actual[i]
+            @message = -> "Spy ##{i+1} wasn't called after spy ##{i}"
+            return false
+
+      return true
+
+    #
+    # Checks the exact equality of tag including attributes and content
+    # with the posibility to check attributes values by regexp
+    #
+    # @example
+    #   tag = "<div class='foo' id='bar'>foo</div>"
+    #   tag.toBeTag 'div', 'foo', class: 'foo', id: /\S+/
+    #
+    toBeTag: (tagName, content, attrs) ->
+      @message = =>
+        "Expected #{@actual} to be a tag #{tagName} with attributes #{JSON.stringify attrs} and content '#{content}'"
+
+      tag = $ @actual
+
+      # Is it alone?
+      flag = tag.length == 1
+
+      # Tag name matches?
+      flag &&= tag[0].nodeName == tagName.toUpperCase()
+
+      # Content matches?
+      flag &&= tag.html() == content if content != false
+
+      # Same number of attributes?
+      flag &&= tag[0].attributes.length == Object.keys(attrs).length
+
+      # Attributes match?
+      for name, val of attrs
+        if val.constructor == RegExp
+          flag &&= tag.attr(name).match(val)
+        else
+          flag &&= tag.attr(name) == val
+
+      flag

data/spec/joosy/core/application_spec.coffee

@@ -1,27 +1,27 @@
 describe "Joosy.Application", ->
 
   beforeEach ->
-    sinon.stub(Joosy.Router, "__setupRoutes")
-    @seedGround()
+    sinon.stub Joosy.Router, "__setupRoutes"
+    @$ground.seed()
 
   afterEach ->
     Joosy.Router.__setupRoutes.restore()
 
-  it "should initialize", ->
-    Joosy.Application.initialize 'app', '#application', router: {foo: 'bar'}
+  it "initializes", ->
+    Joosy.Application.initialize 'app', '#application', foo: {bar: 'baz'}
     expect(Joosy.Application.page).toBeUndefined()
     expect(Joosy.Application.selector).toEqual '#application'
     expect(Joosy.Router.__setupRoutes.callCount).toEqual 1
     expect(Joosy.Application.name).toEqual 'app'
-    expect(Joosy.Application.config.router.foo).toEqual 'bar'
-
-  it "should set container", ->
+    expect(Joosy.Application.config.foo.bar).toEqual 'baz'
     expect(Joosy.Application.content()).toEqual $('#application')
 
-  it "should properly initialize and save pages", ->
+  it "manages pages", ->
     spy = sinon.spy()
+
     class Page1
       constructor: spy
+
     class Page2
       constructor: spy
 

data/spec/joosy/core/helpers/view_spec.coffee

@@ -1,10 +1,14 @@
 describe "Joosy.Helpers.View", ->
 
+  # Shortcut
   h = Joosy.Helpers.Application
 
-  it "renders tag with string inner", ->
-    expect(h.tag 'div', {id: 'ololo'}, 'test').toEqual '<div id="ololo">test</div>'
+  it "renders tag with string content", ->
+    tag = h.tag 'div', {id: 'id'}, 'content'
+    expect(tag).toEqual '<div id="id">content</div>'
 
-  it "renders tag with lambda inner", ->
-    data = h.tag 'div', {id: 'ololo'}, -> h.tag 'div', {id: 'ololo'}, 'test'
-    expect(data).toEqual '<div id="ololo"><div id="ololo">test</div></div>'
+  it "renders tag with lambda content", ->
+    tag = h.tag 'div', {id: 'id'}, -> 
+      h.tag 'div', {id: 'id2'}, 'content'
+
+    expect(tag).toEqual '<div id="id"><div id="id2">content</div></div>'

data/spec/joosy/core/helpers/widgets_spec.coffee

@@ -1,17 +1,50 @@
 describe "Joosy.Helpers.Widgets", ->
 
-  h = Joosy.Helpers.Application
-
   beforeEach ->
-    h.onRefresh = sinon.spy()
+    @$ground.seed()
+
+    # Widget we are going to include using helper
+    class @Widget extends Joosy.Widget
+      @view -> "test"
+
+    # Least possible configuration capable of using helper
+    class @Renderer extends Joosy.Module
+      @include Joosy.Modules.Renderer
+      @include Joosy.Modules.TimeManager
+      @include Joosy.Modules.WidgetsManager
+
+    @renderer = new @Renderer
+    @widget   = new @Widget
+    @template = (context) => context.widget 'div', @widget
+
+  it "renders widget tag", ->
+    runs ->
+      @$ground.find('#header').html @renderer.render(@template)
 
-  afterEach ->
-    delete h.onRefresh
+      expect(@$ground.find('#header').html()).toBeTag 'div', '',
+        id: /__joosy\d+/
 
   it "renders widget tag", ->
-    expect(h.widget 'div', (->)).toBeTag 'div', '', id: /\S{36}/
-    expect(h.onRefresh.callCount).toEqual 1
+    runs ->
+      @template = (context) => context.widget 'div', {class: 'test'}, @widget
+
+      @$ground.find('#header').html @renderer.render(@template)
+
+      expect(@$ground.find('#header').html()).toBeTag 'div', '',
+        id: /__joosy\d+/
+        class: 'test'
+
+  it "bootstraps widget", ->
+    runs ->
+      @$ground.find('#header').html @renderer.render(@template)
+
+      # At the first step only the container will be injected into HTML
+      expect(@$ground.find('#header').html()).toBeTag 'div', '',
+        id: /__joosy\d+/
+
+    waits 0
 
-  it "renders widget tag with given classes", ->
-    expect(h.widget 'div.class1.class2', (->)).toBeTag 'div', '', id: /\S{36}/, class: 'class1 class2'
-    expect(h.onRefresh.callCount).toEqual 1
+    runs ->
+      # But at the next asynchronous tick, widget will be emerged
+      expect(@$ground.find('#header').html()).toBeTag 'div', 'test',
+        id: /__joosy\d+/

data/spec/joosy/core/joosy_spec.coffee

@@ -1,41 +1,60 @@
 describe "Joosy", ->
 
-  it "should properly initialize", ->
+  it "initializes", ->
     expect(Joosy.Application.config.debug).toBeFalsy()
     expect(Joosy.Modules).toBeDefined()
     expect(Joosy.Resources).toBeDefined()
 
-  it "should declare namespaces", ->
-    Joosy.namespace 'Namespaces.Test1'
-    Joosy.namespace 'Namespaces.Test2', ->
-      @bingo = 'bongo'
-    expect(window.Namespaces.Test1).toBeDefined()
-    expect(window.Namespaces.Test2.bingo).toEqual('bongo')
+  it "generates proper UUIDs", ->
+    uuids = []
+    2.times -> uuids.push Joosy.uuid()
+    expect(uuids.unique().length).toEqual(2)
+    expect(uuids[0]).toMatch /[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}/
+
+  it "generates proper UIDs", ->
+    uids = []
+    5.times -> uids.push Joosy.uid()
+    expect(uids.unique().length).toEqual(5)
+
+  it "builds proper URLs", ->
+    expect(Joosy.buildUrl 'http://www.org').toEqual('http://www.org')
+    expect(Joosy.buildUrl 'http://www.org#hash').toEqual('http://www.org#hash')
+    expect(Joosy.buildUrl 'http://www.org', {foo: 'bar'}).toEqual('http://www.org?foo=bar')
+    expect(Joosy.buildUrl 'http://www.org?bar=baz', {foo: 'bar'}).toEqual('http://www.org?bar=baz&foo=bar')
 
-  it "should imprint namespace paths in Joosy.Module descendants", ->
-    Joosy.namespace 'Irish', ->
-      class @Pub extends Joosy.Module
+  describe "namespacer", ->
+    it "declares", ->
+      Joosy.namespace 'Namespaces.Test1'
+      Joosy.namespace 'Namespaces.Test2', ->
+        @bingo = 'bongo'
 
-    Joosy.namespace 'British', ->
-      class @Pub extends Joosy.Module
+      expect(window.Namespaces.Test1).toBeDefined()
+      expect(window.Namespaces.Test2.bingo).toEqual('bongo')
 
-    Joosy.namespace 'Keltic', ->
-      class @Pub extends Irish.Pub
+    it "imprints path", ->
+      Joosy.namespace 'Irish', ->
+        class @Pub extends Joosy.Module
 
-    expect(Irish.Pub.__namespace__).toEqual ["Irish"]
-    expect(British.Pub.__namespace__).toEqual ["British"]
-    expect(Keltic.Pub.__namespace__).toEqual ["Keltic"]
+      Joosy.namespace 'British', ->
+        class @Pub extends Joosy.Module
 
-    Joosy.namespace 'Deeply.Nested', ->
-      class @Klass extends Joosy.Module
+      Joosy.namespace 'Keltic', ->
+        class @Pub extends Irish.Pub
 
-    expect(Deeply.Nested.Klass.__namespace__).toEqual ["Deeply", "Nested"]
+      expect(Irish.Pub.__namespace__).toEqual ["Irish"]
+      expect(British.Pub.__namespace__).toEqual ["British"]
+      expect(Keltic.Pub.__namespace__).toEqual ["Keltic"]
 
-    class @Flat extends Joosy.Module
+      Joosy.namespace 'Deeply.Nested', ->
+        class @Klass extends Joosy.Module
 
-    expect(@Flat.__namespace__).toEqual []
+      expect(Deeply.Nested.Klass.__namespace__).toEqual ["Deeply", "Nested"]
 
-  it "should set up helpers", ->
+      class @Flat extends Joosy.Module
+
+      expect(@Flat.__namespace__).toEqual []
+
+  it "declares helpers", ->
     Joosy.helpers 'Hoge', ->
       @fuga = ->
         "piyo"
@@ -43,30 +62,3 @@ describe "Joosy", ->
     expect(window.Joosy.Helpers).toBeDefined()
     expect(window.Joosy.Helpers.Hoge).toBeDefined()
     expect(window.Joosy.Helpers.Hoge.fuga()).toBe "piyo"
-
-  it "should generate proper UUIDs", ->
-    uuids = []
-    2.times ->
-      uuids.push Joosy.uuid()
-    expect(uuids.unique().length).toEqual(2)
-    expect(uuids[0]).toMatch /[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}/
-
-  it "should build proper URLs", ->
-    expect(Joosy.buildUrl 'http://www.org').toEqual('http://www.org')
-    expect(Joosy.buildUrl 'http://www.org#hash').toEqual('http://www.org#hash')
-    expect(Joosy.buildUrl 'http://www.org', {foo: 'bar'}).toEqual('http://www.org?foo=bar')
-    expect(Joosy.buildUrl 'http://www.org?bar=baz', {foo: 'bar'}).toEqual('http://www.org?bar=baz&foo=bar')
-
-  it "should preload images", ->
-    path   = "/spec/javascripts/support/assets/"
-    images = [path+"okay.jpg", path+"okay.jpg"]
-
-    callback = sinon.spy()
-
-    runs -> Joosy.preloadImages path+"coolface.jpg", callback
-    waits(150)
-    runs -> expect(callback.callCount).toEqual(1)
-
-    runs -> Joosy.preloadImages images, callback
-    waits(150)
-    runs -> expect(callback.callCount).toEqual(2)

data/spec/joosy/core/layout_spec.coffee

@@ -1,50 +1,46 @@
 describe "Joosy.Layout", ->
 
   beforeEach ->
-    class @TestLayout extends Joosy.Layout
-    @box = new @TestLayout()
+    class @Layout extends Joosy.Layout
+    @layout = new @Layout
 
-  it "should have appropriate accessors", ->
-    callback_names = ['beforePaint', 'paint', 'erase']
-    callback_names.each (func) =>
-      @TestLayout[func] 'callback'
-      expect(@TestLayout::['__' + func]).toEqual 'callback'
+  it "has appropriate accessors", ->
+    callbackNames = ['beforePaint', 'paint', 'erase']
+    callbackNames.each (callbackName) =>
+      @Layout[callbackName] 'callback'
+      expect(@Layout::['__' + callbackName]).toEqual 'callback'
 
-  it "should have default view", ->
-    @box = new @TestLayout()
-    expect(@box.__renderer instanceof Function).toBeTruthy()
+  it "generates uid", ->
+    @layout.page()
+    expect(@layout.uid).toBeDefined()
 
-  it "should use Router", ->
+  it "uses uid as selector", ->
+    @layout.page()
+    expect(@layout.content().selector).toEqual '#' + @layout.uid
+
+  it "has default view", ->
+    expect(@layout.__renderDefault instanceof Function).toBeTruthy()
+
+  it "integrates with Router", ->
     target = sinon.stub Joosy.Router, 'navigate'
-    @box.navigate 'there'
+    @layout.navigate 'there'
     expect(target.callCount).toEqual 1
     expect(target.alwaysCalledWithExactly 'there').toBeTruthy()
     Joosy.Router.navigate.restore()
 
-  it "should load itself", ->
+  it "loads", ->
     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(@ground)
+    spies.push sinon.spy(@layout, '__assignElements')
+    spies.push sinon.spy(@layout, '__delegateEvents')
+    spies.push sinon.spy(@layout, '__setupWidgets')
+    spies.push sinon.spy(@layout, '__runAfterLoads')
+    @layout.__load(@$ground)
     expect(spies).toBeSequenced()
 
-  it "should unload itself", ->
+  it "unloads", ->
     spies = []
-    spies.push sinon.spy(@box, '__clearTime')
-    spies.push sinon.spy(@box, '__unloadWidgets')
-    spies.push sinon.spy(@box, '__runAfterUnloads')
-    @box.__unload()
+    spies.push sinon.spy(@layout, '__clearTime')
+    spies.push sinon.spy(@layout, '__unloadWidgets')
+    spies.push sinon.spy(@layout, '__runAfterUnloads')
+    @layout.__unload()
     expect(spies).toBeSequenced()
-
-  it "should generate uuid", ->
-    sinon.spy Joosy, 'uuid'
-    @box.yield()
-    expect(Joosy.uuid.callCount).toEqual 1
-    expect(@box.uuid).toBeDefined()
-    Joosy.uuid.restore()
-
-  it "should uuid as selector", ->
-    @box.yield()
-    expect(@box.content().selector).toEqual '#' + @box.uuid