RubyGems - joosy - Versions diffs - 0.1.0.alpha → 1.0.0.RC1 - Mend

joosy 0.1.0.alpha → 1.0.0.RC1

Files changed (123) hide show

data/lib/rails/generators/joosy/templates/app_resources_predefiner.js.coffee.erb ADDED Viewed

@@ -0,0 +1,11 @@
+# Whitelist here modules and sub-modules which resources should be predefined
+# e.g. ['front', 'front/products', nil] if you have
+# Front::SomeController and Front::Products::AnotherController
+# with the associated namespaces in your routes
+# and want to predefine resources with no namespace
+# Joosy.defineResources <%= "<%= Joosy::SprocketsHelper.joosy_resources(['" + file_name + "', nil]).to_json %" + ">" %>
+# or predefine all resources
+Joosy.defineResources <%= "<%= Joosy::SprocketsHelper.joosy_resources.to_json %" + ">" %>

data/lib/rails/generators/joosy/templates/preload.html.erb CHANGED Viewed

@@ -1,22 +1,21 @@
 <!DOCTYPE html>
 <html>
   <head>
-    <title>Loading...</title>
+    <title><%= file_path %></title>
     <script type="text/javascript">
-      window.preload = {
-        libraries:   <%= "<%= extract_sources_and_sizes_from_include_tag('#{file_path}') %"+">" %>,
-        development: <%= "<%= Rails.env.development? %"+">" %>
+      window.joosy = {
+        libraries: <%= "<%= extract_sources_and_sizes_from_include_tag('#{file_path}') %"+">" %>,
+        environment: '<%= "<%= Rails.env.to_s %"+">" %>'
       };
     </script>
     <%= "<%= stylesheet_link_tag 'application' %"+">" %>
-    <%= "<%= javascript_include_tag 'application' %"+">" %>
-    <%= "<%= javascript_include_tag '#{file_path}_preloader' %"+">" %>
     <%= "<%= csrf_meta_tags %"+">" %>
   </head>
   <body>
+    <%= "<%= javascript_include_tag '#{file_path}_preloader' %"+">" %>
     <div id="application">
       <div id="preloader">
         Loading application...

data/lib/rails/generators/joosy/templates/preload.html.haml CHANGED Viewed

@@ -1,20 +1,18 @@
 !!! 5
 %html
   %head
-    %title> Loading...
+    %title> <%= file_path %>
     javascript:
       window.preload = {
-        libraries:   #{extract_sources_and_sizes_from_include_tag('<%= file_path %>')},
-        development: #{Rails.env.development?}
+        libraries: #{extract_sources_and_sizes_from_include_tag('<%= file_path %>')}
       };
     = stylesheet_link_tag 'application'
-    = javascript_include_tag 'application'
-    = javascript_include_tag '<%= file_path %>_preloader'
     = csrf_meta_tags
   %body
+    = javascript_include_tag '<%= file_path %>_preloader'
     #application
       #preloader
         Loading application...

data/lib/rails/generators/joosy/widget_generator.rb CHANGED Viewed

@@ -18,7 +18,14 @@ module Joosy
       protected
       def app_path
-        File.join class_path
+        unless class_path.size == 1
+          puts <<HELP
+Usage: rails generate joosy:widget joosy_app_name/widget_name
+Tip: do not add Widget suffix to widget_name
+HELP
+          exit 1
+        end
+        class_path[0]
       end
     end
   end

data/lib/rails/resources_with_joosy.rb ADDED Viewed

@@ -0,0 +1,11 @@
+require 'action_dispatch/routing/mapper'
+module ActionDispatch::Routing::Mapper::Resources
+  def resources_with_joosy(*resources, &block)
+    resources_without_joosy(*resources, &block).tap do
+      namespace = Joosy::Rails::Engine.resources[@scope[:module]] ||= {}
+      namespace[resources[0].to_s.singularize] = "#{@scope[:shallow_path]}/#{resources[0]}"
+    end
+  end
+  alias_method_chain :resources, :joosy
+end

data/spec/javascripts/helpers/spec_helper.js.coffee CHANGED Viewed

@@ -1,6 +1,11 @@
 beforeEach ->
+  Joosy.Resource.Generic.resetIdentity()
+  window.JST = {}
   $('body').append('<div id="ground">')
   @ground = $('body #ground')
   @seedGround = ->
     @ground.html('
       <div id="application" class="application">
@@ -20,5 +25,25 @@ beforeEach ->
       </div>
     ')
+  @addMatchers
+    toBeSequenced: () ->
+      if !Object.isArray(@actual) || @actual.length == 0
+        console.log 'toBeSequenced: not array or empty array given'
+        return false
+      i = 0
+      for spy in @actual
+        unless spy.callCount == 1
+          console.log "toBeSequenced: spy ##{i} was called #{spy.callCount} times"
+          return false
+        i++
+      if @actual.length > 1
+        for spy in @actual.from(1)
+          i = @actual.indexOf spy
+          previous = @actual[i - 1]
+          unless spy.calledAfter previous
+            console.log "toBeSequenced: spy ##{i} wasn't called after spy ##{i - 1}"
+            return false
+      return true
 afterEach ->
   @ground.remove() unless @polluteGround

data/spec/javascripts/joosy/core/application_spec.js.coffee ADDED Viewed

@@ -0,0 +1,40 @@
+describe "Joosy.Application", ->
+  beforeEach ->
+    sinon.stub(Joosy.Router, "__setupRoutes")
+    @seedGround()
+  afterEach ->
+    Joosy.Router.__setupRoutes.restore()
+  it "should initialize", ->
+    Joosy.Application.initialize 'app', '#application'
+    expect(Joosy.Application.page).toBeUndefined()
+    expect(Joosy.Application.selector).toEqual '#application'
+    expect(Joosy.Application.sandboxSelector).toMatch /#[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}/
+    expect($(Joosy.Application.sandboxSelector).length).toEqual 1
+    expect(Joosy.Router.__setupRoutes.callCount).toEqual 1
+    expect(Joosy.Application.name).toEqual 'app'
+  it "should set container", ->
+    expect(Joosy.Application.content()).toEqual $('#application')
+  it "should properly initialize and save pages", ->
+    spy = sinon.spy()
+    class Page1
+      constructor: spy
+    class Page2
+      constructor: spy
+    Joosy.Application.setCurrentPage(Page1, {foo: 'bar'})
+    expect(Joosy.Application.page instanceof Page1).toBeTruthy()
+    expect(spy.callCount).toEqual 1
+    expect(spy.args[0]).toEqual [{foo: 'bar'}, undefined]
+    Joosy.Application.setCurrentPage(Page2, {bar: 'baz'})
+    expect(Joosy.Application.page instanceof Page2).toBeTruthy()
+    expect(spy.callCount).toEqual 2
+    expect(spy.args[1][0]).toEqual {bar: 'baz'}
+    expect(spy.args[1][1] instanceof Page1).toBeTruthy()

data/spec/javascripts/joosy/core/form_spec.js.coffee ADDED Viewed

@@ -0,0 +1,200 @@
+describe "Joosy.Form", ->
+  beforeEach ->
+    @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'/></form>"
+    @putForm  = "<form id='put' method='put'><input name='test[camel_baz]'/></form>"
+    @moreForm = "<form id='more' method='put'><input name='test[ololo]'/></form>"
+    @ground.find('#sidebar').after(@nudeForm).after(@putForm).after(@moreForm)
+    @nudeForm = $('#nude')
+    @putForm  = $('#put')
+    @moreForm = $('#more')
+    class Test extends Joosy.Resource.REST
+      @entity 'test'
+    @Test = Test
+    @resource = Test.build
+      id: 1,
+      foo: 'foo',
+      bar: 'bar'
+      camelBaz: 'baz'
+      bool: true
+  afterEach ->
+    @server.restore()
+  describe "Initialization", ->
+    beforeEach ->
+      @spy = sinon.spy $.fn, 'ajaxForm'
+    afterEach ->
+      @spy.restore()
+    it "should properly act with options", ->
+      formWithProperties = new Joosy.Form @nudeForm, invalidationClass: 'fluffy'
+      expect(formWithProperties.container).toEqual @nudeForm
+      expect(formWithProperties.invalidationClass).toEqual 'fluffy'
+      expect(formWithProperties.fields.length).toEqual 3
+      expect(@spy.callCount).toEqual 1
+    it "should properly act with callback", ->
+      formWithCallback = new Joosy.Form @putForm, callback=sinon.spy()
+      expect(formWithCallback.container).toEqual @putForm
+      expect(formWithCallback.invalidationClass).toEqual 'field_with_errors'
+      expect(formWithCallback.success).toBe callback
+      expect(formWithCallback.fields.length).toEqual 1
+      expect(@spy.callCount).toEqual 1
+    it "should hijack form method if it differs from POST/GET", ->
+      form   = new Joosy.Form @putForm, callback=sinon.spy()
+      marker = @putForm.find "input[type=hidden]"
+      expect(@putForm.attr('method')?.toLowerCase()).toEqual 'post'
+      expect(marker.attr 'name').toEqual '_method'
+      expect(marker.attr 'value').toEqual 'put'
+  describe "Filling", ->
+    beforeEach ->
+      @nudeForm   = new Joosy.Form @nudeForm
+      @putForm    = new Joosy.Form @putForm
+      @moreForm   = new Joosy.Form @moreForm
+    it "should fill form, set proper action and method and store resource", ->
+      @nudeForm.fill @resource
+      expect(@nudeForm.fields[0].value).toEqual 'foo'
+      expect(@nudeForm.fields[1].value).toEqual 'bar'
+      expect(@nudeForm.fields[2].checked).toEqual true
+      expect(@nudeForm.fields[2].value).toEqual '1'
+      expect(@nudeForm.container.attr('method').toLowerCase()).toEqual 'post'
+      expect(@nudeForm.container.attr 'action').toEqual '/tests/1'
+      expect(@nudeForm.__resource).toEqual @resource
+    it "should fill form with camelized properties", ->
+      @putForm.fill @resource
+      expect(@putForm.fields[0].value).toEqual 'baz'
+      expect(@putForm.container.attr('method').toLowerCase()).toEqual 'post'
+      expect(@putForm.container.attr 'action').toEqual '/tests/1'
+    it "should fill form with decorator", ->
+      @moreForm.fill @resource,
+        decorator: (e) ->
+          e.ololo = e.camelBaz
+          e
+      expect(@moreForm.fields[0].value).toEqual 'baz'
+    it "should fill form with extended action", ->
+      @nudeForm.fill @resource,
+        action: @resource.memberPath(from: 'calculate')
+      expect(@nudeForm.fields[0].value).toEqual 'foo'
+      expect(@nudeForm.fields[1].value).toEqual 'bar'
+      expect(@nudeForm.container.attr 'action').toEqual '/tests/1/calculate'
+      resource = @Test.build 'someId'
+      @nudeForm.fill resource,
+        action: resource.memberPath(from: 'calculate')
+      expect(@nudeForm.container.attr 'action').toEqual '/tests/someId/calculate'
+  describe "Callbacks", ->
+    beforeEach ->
+      @nudeForm = new Joosy.Form @nudeForm, @spy=sinon.spy()
+      @nudeForm.fill @resource
+      @nudeForm.container.submit()
+      @target = @server.requests.last()
+    it "should trigger 'success'", ->
+      expect(@target.method).toEqual 'POST'
+      expect(@target.url).toEqual '/tests/1'
+      @target.respond 200, 'Content-Type': 'application/json', '{"form": "works"}'
+      expect(@spy.callCount).toEqual 1
+      expect(@spy.args[0][0]).toEqual {form: 'works'}
+    it "should fill class for invalidated fields by default", ->
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
+      expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
+    it "should trigger 'error' and complete default action if it returned true", ->
+      @nudeForm.error = sinon.spy ->
+        true
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
+      expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
+      expect(@nudeForm.error.callCount).toEqual 1
+      expect(@nudeForm.error.args[0][0]).toEqual
+        "foo": "error!"
+    it "should trigger 'error' and skip default action if it returned false", ->
+      @nudeForm.error = sinon.spy ->
+        false
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
+      expect($(@nudeForm.fields[0]).attr 'class').toNotEqual 'field_with_errors'
+      expect(@nudeForm.error.callCount).toEqual 1
+    it "should clear fields before another submit", ->
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
+      expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
+      @nudeForm.container.submit()
+      expect($(@nudeForm.fields[0]).attr 'class').toNotEqual 'field_with_errors'
+    it "should trigger 'before' and do default action if it returns true", ->
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
+      expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
+      @nudeForm.before = sinon.spy ->
+        true
+      @nudeForm.container.submit()
+      expect($(@nudeForm.fields[0]).attr 'class').toNotEqual 'field_with_errors'
+      expect(@nudeForm.before.callCount).toEqual 1
+    it "should trigger 'before' and skip default action if it returns false", ->
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
+      expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
+      @nudeForm.before = sinon.spy ->
+        false
+      @nudeForm.container.submit()
+      expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
+      expect(@nudeForm.before.callCount).toEqual 1
+  describe "Error response handling", ->
+    beforeEach ->
+      @nudeForm = new Joosy.Form @nudeForm, @spy=sinon.spy()
+    it "should prepare simple response", ->
+      errors = {zombie: ['suck'], puppies: ['rock']}
+      result = @nudeForm.__stringifyErrors(errors)
+      expect(result).toEqual zombie: ['suck'], puppies: ['rock']
+    it "should prepare inline response", ->
+      errors = {"zombie.in1.subin1": ['suck'], "zombie.in2": ['rock']}
+      result = @nudeForm.__stringifyErrors(errors)
+      expect(result).toEqual {"zombie[in1][subin1]": ['suck'], "zombie[in2]": ['rock']}
+    it "should prepare inline response with resource attached", ->
+      @nudeForm.fill @resource
+      errors = {"zombie.in1.subin1": ['suck'], "zombie.in2": ['rock']}
+      result = @nudeForm.__stringifyErrors(errors)
+      expect(result).toEqual {"test[zombie][in1][subin1]": ['suck'], "test[zombie][in2]": ['rock']}
+    it "should prepare simple response with resource attached", ->
+      @nudeForm.fill @resource
+      errors = {zombie: ['suck'], puppies: ['rock']}
+      result = @nudeForm.__stringifyErrors(errors)
+      expect(result).toEqual { "test[zombie]": ['suck'], "test[puppies]": ['rock'] }
+    it "should prepare complexe response", ->
+      @nudeForm.fill @resource
+      errors = {fluffies: {zombie: {mumbas: ['ololo']}}}
+      result = @nudeForm.__stringifyErrors(errors)
+      expect(result).toEqual { "fluffies[zombie][mumbas]": ['ololo'] }

data/spec/javascripts/joosy/core/helpers/forms_spec.js.coffee ADDED Viewed

@@ -0,0 +1,103 @@
+describe "Joosy.Helpers.Form", ->
+  beforeEach ->
+    @addMatchers toBeTag: (tagName, content, attrs) ->
+      @message = =>
+        "Expected #{@actual} to be a tag #{tagName} with attributes #{JSON.stringify attrs} and content #{content}"
+      tag = $ @actual
+      flag = true
+      flag = flag && tag.length == 1
+      flag = flag && tag[0].nodeName == tagName.toUpperCase()
+      flag = flag && tag.html() == content
+      for name, val of attrs
+        flag = flag && tag.attr(name) == val
+      flag = flag && tag[0].attributes.length == Object.keys(attrs).length
+      flag
+  class Test extends Joosy.Resource.Generic
+    @entity 'test'
+  h = Joosy.Helpers.Application
+  resource = Test.build 1
+  describe "simple", ->
+    ['text', 'file', 'hidden', 'password'].each (type) =>
+      it "renders #{type}Field", ->
+        expect(h["#{type}Field"] 'a', 'b', {a: 'b'}).toBeTag 'input', '', id: 'a_b', name: 'a[b]', a: 'b', type: type
+    it "renders nested methods", ->
+      expect(h.textField 'a', '[b]', {a: 'b'}).toBeTag 'input', '', id: 'a_b', name: 'a[b]', a: 'b', type: 'text'
+      expect(h.textField 'a', '[b][c]', {a: 'b'}).toBeTag 'input', '', id: 'a_b_c', name: 'a[b][c]', a: 'b', type: 'text'
+    it "renders label", ->
+      expect(h.label 'a', 'b', {a: 'b'}, 'test').toBeTag 'label', 'test', for: 'a_b', a: 'b'
+    it "renders checkBox", ->
+      tags = h.checkBox('a', 'b', {a: 'b'}).match(/<[^>]+>/g)
+      expect(tags[0]).toBeTag 'input', '', value: '0', id: 'a_b', name: 'a[b]', type: 'hidden'
+      expect(tags[1]).toBeTag 'input', '', value: '1', id: 'a_b', name: 'a[b]', type: 'checkbox', a: 'b'
+    it "renders radioButton", ->
+      expect(h.radioButton 'a', 'b', 'test', {a: 'b'}).toBeTag 'input', '', value: 'test', id: 'a_b', name: 'a[b]', type: 'radio', a: 'b'
+    it "renders textArea", ->
+      expect(h.textArea 'a', 'b', {a: 'b', value: 'foo'}).toBeTag 'textarea', 'foo', id: 'a_b', name: 'a[b]', a: 'b'
+    it "renders formFor", ->
+      callback = sinon.spy()
+      expect(h.formFor resource, callback).toMatch /<form id=".*"><\/form>/
+      expect(callback.callCount).toEqual 1
+      expect(callback.args[0][0].label?).toBeTruthy()
+  describe "resource", ->
+    callback = sinon.spy()
+    h.formFor(resource, callback)
+    form = callback.args[0][0]
+    ['text', 'file', 'hidden', 'password'].each (type) =>
+      it "renders #{type}Field", ->
+        expect(form["#{type}Field"] 'b', {a: 'b'}).toBeTag 'input', '', id: 'test_b', name: 'test[b]', a: 'b', type: type
+    it "renders label", ->
+      expect(form.label 'b', {a: 'b'}, 'test').toBeTag 'label', 'test', for: 'test_b', a: 'b'
+    it "renders checkBox", ->
+      tags = form.checkBox('b', {a: 'b'}).match(/<[^>]+>/g)
+      expect(tags[0]).toBeTag 'input', '', value: '0', id: 'test_b', name: 'test[b]', type: 'hidden'
+      expect(tags[1]).toBeTag 'input', '', value: '1', id: 'test_b', name: 'test[b]', type: 'checkbox', a: 'b'
+    it "renders radioButton", ->
+      expect(form.radioButton 'b', 'test', {a: 'b'}).toBeTag 'input', '', value: 'test', id: 'test_b', name: 'test[b]', type: 'radio', a: 'b'
+    it "renders textArea", ->
+      expect(form.textArea 'b', {a: 'b', value: 'foo'}).toBeTag 'textarea', 'foo', id: 'test_b', name: 'test[b]', a: 'b'
+  describe "resource with extendIds", ->
+    callback = sinon.spy()
+    h.formFor(resource, extendIds: true, callback)
+    form = callback.args[0][0]
+    ['text', 'file', 'hidden', 'password'].each (type) =>
+      it "renders #{type}Field", ->
+        expect(form["#{type}Field"] 'b', {a: 'b'}).toBeTag 'input', '', id: 'test_1_b', name: 'test[b]', a: 'b', type: type
+    it "renders label", ->
+      expect(form.label 'b', {a: 'b'}, 'test').toBeTag 'label', 'test', for: 'test_1_b', a: 'b'
+    it "renders checkBox", ->
+      tags = form.checkBox('b', {a: 'b'}).match(/<[^>]+>/g)
+      expect(tags[0]).toBeTag 'input', '', value: '0', id: 'test_1_b', name: 'test[b]', type: 'hidden'
+      expect(tags[1]).toBeTag 'input', '', value: '1', id: 'test_1_b', name: 'test[b]', type: 'checkbox', a: 'b'
+    it "renders radioButton", ->
+      expect(form.radioButton 'b', 'test', {a: 'b'}).toBeTag 'input', '', value: 'test', id: 'test_1_b', name: 'test[b]', type: 'radio', a: 'b'
+    it "renders textArea", ->
+      expect(form.textArea 'b', {a: 'b', value: 'foo'}).toBeTag 'textarea', 'foo', id: 'test_1_b', name: 'test[b]', a: 'b'

data/spec/javascripts/joosy/core/helpers/view_spec.js.coffee ADDED Viewed

@@ -0,0 +1,10 @@
+describe "Joosy.Helpers.View", ->
+  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 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>'

data/spec/javascripts/joosy/core/joosy_spec.js.coffee ADDED Viewed

@@ -0,0 +1,97 @@
+describe "Joosy", ->
+  it "should properly initialize", ->
+    expect(Joosy.debug).toBeFalsy()
+    expect(Joosy.Modules).toBeDefined()
+    expect(Joosy.Resource).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 "should imprint namespace paths in Joosy.Module descendants", ->
+    Joosy.namespace 'Irish', ->
+      class @Pub extends Joosy.Module
+    Joosy.namespace 'British', ->
+      class @Pub extends Joosy.Module
+    Joosy.namespace 'Keltic', ->
+      class @Pub extends Irish.Pub
+    expect(Irish.Pub.__namespace__).toEqual ["Irish"]
+    expect(British.Pub.__namespace__).toEqual ["British"]
+    expect(Keltic.Pub.__namespace__).toEqual ["Keltic"]
+    Joosy.namespace 'Deeply.Nested', ->
+      class @Klass extends Joosy.Module
+    expect(Deeply.Nested.Klass.__namespace__).toEqual ["Deeply", "Nested"]
+    class @Flat extends Joosy.Module
+    expect(@Flat.__namespace__).toEqual []
+  it "should set up helpers", ->
+    Joosy.helpers 'Hoge', ->
+      @fuga = ->
+        "piyo"
+    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)
+  it "should define resource", ->
+    container = {}
+    Joosy.defineResource 'foo', '', container
+    expect(Object.isFunction container.Foo).toBeTruthy()
+    expect(Object.isFunction container.FoosCollection).toBeTruthy()
+    Joosy.defineResource 'boo'
+    expect(Object.isFunction Boo).toBeTruthy()
+    expect(Object.isFunction BoosCollection).toBeTruthy()
+  it "should define resource", ->
+    window.Defined = 'this'
+    window.DefinedsCollection = 'that'
+    Joosy.defineResources
+      '':
+        test: '/test'
+        defined: 'no'
+      'Scope.Test':
+        another: ''
+    expect(Object.isFunction Test).toBeTruthy()
+    expect(Object.isFunction TestsCollection).toBeTruthy()
+    expect(Object.isFunction Scope.Test.Another).toBeTruthy()
+    expect(Object.isFunction Scope.Test.AnothersCollection).toBeTruthy()
+    expect(Defined).toEqual 'this'
+    expect(DefinedsCollection).toEqual 'that'

data/spec/javascripts/joosy/core/layout_spec.js.coffee ADDED Viewed

@@ -0,0 +1,50 @@
+describe "Joosy.Layout", ->
+  beforeEach ->
+    class @TestLayout extends Joosy.Layout
+    @box = new @TestLayout()
+  it "should have appropriate accessors", ->
+    callback_names = ['beforePaint', 'paint', 'erase']
+    callback_names.each (func) =>
+      @TestLayout[func] 'callback'
+      expect(@TestLayout::['__' + func]).toEqual 'callback'
+  it "should have default view", ->
+    @box = new @TestLayout()
+    expect(@box.__renderer instanceof Function).toBeTruthy()
+  it "should use Router", ->
+    target = sinon.stub Joosy.Router, 'navigate'
+    @box.navigate 'there'
+    expect(target.callCount).toEqual 1
+    expect(target.alwaysCalledWithExactly 'there').toBeTruthy()
+    Joosy.Router.navigate.restore()
+  it "should load itself", ->
+    spies = []
+    spies.push sinon.spy(@box, 'refreshElements')
+    spies.push sinon.spy(@box, '__delegateEvents')
+    spies.push sinon.spy(@box, '__setupWidgets')
+    spies.push sinon.spy(@box, '__runAfterLoads')
+    @box.__load(@ground)
+    expect(spies).toBeSequenced()
+  it "should unload itself", ->
+    spies = []
+    spies.push sinon.spy(@box, '__clearTime')
+    spies.push sinon.spy(@box, '__unloadWidgets')
+    spies.push sinon.spy(@box, '__runAfterUnloads')
+    @box.__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