modularity-rails 0.9.0 → 0.9.1

data/demo/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/demo/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/demo/spec/javascripts/konacha_config.coffee

@@ -0,0 +1 @@
+Konacha.mochaOptions.ignoreLeaks = true

data/demo/spec/javascripts/mixins/closable_spec.coffee

@@ -0,0 +1,98 @@
+#= require spec_helper
+#= require mixins/closable
+
+# A standard closable module.
+class window.ClosableModule1 extends modularity.Module
+  @mixin modularity.closable
+
+
+describe 'Closable', ->
+
+  spy_alert = null
+  beforeEach ->
+    template 'closable'
+    spy_alert = sinon.stub window, 'alert'
+
+  afterEach ->
+    spy_alert.restore()
+
+  describe 'constructor', ->
+    it 'shows an alert if there is no close button', ->
+      new ClosableModule1('#konacha #closable3')
+      window.alert.should.have.been.called
+      window.alert.args[0][0].should.match(/close button not found/i)
+
+    it 'shows no alert if there is a close button', ->
+      new ClosableModule1('#konacha #closable1')
+      window.alert.should.not.have.been.called
+
+    it 'finds the close button div automatically', ->
+      new ClosableModule1('#konacha #closable1')
+      $('#konacha #closable1 .CloseButton').click()
+      $('#konacha #closable1').should.have.length 0
+
+
+  describe 'when clicking the close button', ->
+
+    it "calls the closable_closing hook on the object if it exists", ->
+
+      # A closable module with the 'closing' hook.
+      class ClosableModule extends modularity.Module
+        @mixin modularity.closable
+
+        constructor: ->
+          super
+          @closing_hook_got_called = no
+
+        closable_closing: => @closing_hook_got_called = yes
+
+      module = new ClosableModule('#konacha #closable1')
+      $('#konacha #closable1 .CloseButton').click()
+      module.closing_hook_got_called.should.be.true
+
+
+    it "calls the closable_closed hook on the object if it exists", ->
+
+      # A closable module with the 'closed' hook.
+      class ClosableModule extends modularity.Module
+        @mixin modularity.closable
+
+        constructor: ->
+          super
+          @closed_hook_got_called = no
+
+        closable_closed: => @closed_hook_got_called = yes
+
+      module = new ClosableModule('#konacha #closable1')
+      $('#konacha #closable1 .CloseButton').click()
+      module.closed_hook_got_called.should.be.true
+
+
+    it "aborts the close operation if the closable_closing method returns false", ->
+
+      class ClosableModuleWithHookThatReturnsFalse extends modularity.Module
+        @mixin modularity.closable
+        closable_closing: -> false
+
+      module = new ClosableModuleWithHookThatReturnsFalse('#konacha #closable1')
+      module.bind_event('closed', (spy = sinon.spy()))
+
+      $('#konacha #closable1 .CloseButton').click()
+
+      spy.should.not.have.been.called
+
+
+    it 'removes the container', ->
+      new ClosableModule1('#konacha #closable1')
+      $('#konacha #closable1 .CloseButton').click()
+
+      $('#konacha #closable1').should.have.length 0
+
+
+    it "fires the 'closed' event", ->
+      closable_module = new ClosableModule1('#konacha #closable1')
+      closable_module.bind_event('closed', (spy = sinon.spy()))
+
+      $('#konacha #closable1 .CloseButton').click()
+
+      spy.should.have.been.calledOnce

data/{spec → demo/spec}/javascripts/modularity_spec.coffee

@@ -1,267 +1,270 @@
 #= require spec_helper
 
-describe 'setting up test environment', ->
+class window.TestModule extends modularity.Module
 
-  it 'loading libraries', ->
-    load_modularity()
 
-  it 'defining test classes', ->
-
-    class window.TestModule extends modularity.Module
-      constructor: (container) ->
-        super
+describe 'modularity', ->
 
+  alert_stub = null
+  beforeEach ->
+    template 'modularity'
+    alert_stub = sinon.stub window, 'alert'
 
-describe 'modularity', ->
+  afterEach ->
+    alert_stub.restore()
 
-  template 'test.html'
 
   describe 'constructor', ->
 
-    beforeEach ->
-      spyOn window, 'alert'
-
     it "is defined on the 'window' object", ->
-      expect(modularity.Module).not.toBeUndefined()
+      modularity.Module.should.not.be.undefined
 
     it 'shows an error if no container is given', ->
       new TestModule()
-      expect(alert).toHaveBeenCalled()
+      window.alert.should.have.been.called
 
     it 'tries to load the DOM if the given container is a string', ->
-      new TestModule('#test #module_container')
-      expect(alert).not.toHaveBeenCalled()
+      new TestModule('#konacha #module_container')
+      window.alert.should.not.have.been.called
 
     it 'shows an error if the container is not a jQuery object', ->
       new TestModule({})
-      expect(alert).toHaveBeenCalled()
+      window.alert.should.have.been.called
 
     it 'shows an error if the container is an empty jQuery object', ->
-      new TestModule($('#test .zonk'))
-      expect(alert).toHaveBeenCalled()
+      new TestModule($('#konacha .zonk'))
+      window.alert.should.have.been.called
 
     it 'shows an error if the container has more than one elements', ->
-      new TestModule($('#test .double'))
-      expect(alert).toHaveBeenCalled()
+      new TestModule($('#konacha .double'))
+      window.alert.should.have.been.called
 
     it "allows to provide 'testing' in tests", ->
       new TestModule('testing')
-      expect(alert).not.toHaveBeenCalled()
+      window.alert.should.not.have.been.called
 
 
   describe 'assert', ->
 
-    beforeEach ->
-      spyOn window, 'alert'
-
     it 'shows an alert with the given message if the given condition is false', ->
       modularity.assert false, 'Message'
-      expect(alert).toHaveBeenCalledWith("Message")
+      window.alert.should.have.been.calledWith "Message"
 
     it 'fails when the condition is null', ->
       modularity.assert null, 'Message'
-      expect(alert).toHaveBeenCalledWith("Message")
+      window.alert.should.have.been.calledWith "Message"
 
     it 'fails when the condition is undefined', ->
       modularity.assert undefined, 'Message'
-      expect(alert).toHaveBeenCalledWith("Message")
+      window.alert.should.have.been.calledWith "Message"
 
     it 'fails when the condition is an empty array', ->
       modularity.assert [], 'Message'
-      expect(alert).toHaveBeenCalledWith("Message")
+      window.alert.should.have.been.calledWith "Message"
 
     it 'fails when the condition is an empty string', ->
       modularity.assert '', 'Message'
-      expect(alert).toHaveBeenCalledWith("Message")
+      window.alert.should.have.been.calledWith "Message"
 
     it 'passes when the condition is a string', ->
       modularity.assert '123', 'Message'
-      expect(alert).not.toHaveBeenCalled()
+      window.alert.should.not.have.been.called
 
     it "returns false if the condition doesn't pass", ->
-      expect(modularity.assert(false)).toBeFalsy()
+      modularity.assert(false).should.be.false
 
     it "returns true if the condition passes", ->
-      expect(modularity.assert('123')).toBeTruthy()
+      modularity.assert('123').should.be.true
 
 
   describe 'jQuery Integration', ->
 
-    beforeEach ->
-      spyOn window, 'alert'
-
     it 'works', ->
-      $('#test #module_container').module(TestModule)
-      expect(alert).not.toHaveBeenCalled()
+      $('#konacha #module_container').module(TestModule)
+      window.alert.should.not.have.been.called
 
     it 'returns the created instance', ->
-      result = $('#test #module_container').module(modularity.Module)
-      expect(result).toBeDefined()
-      expect(typeof result).toEqual('object')
+      result = $('#konacha #module_container').module(modularity.Module)
+      result.should.exist
+      result.should.be.instanceOf modularity.Module
 
     it 'returns an error if the given parameter is not a class', ->
-      $('#test').module()
-      expect(alert).toHaveBeenCalled()
+      $('#konacha').module()
+      window.alert.should.have.been.called
 
     it 'returns an error if the jQuery object is empty.', ->
-      $('#test #zonk').module(modularity.Module)
-      expect(alert).toHaveBeenCalled()
+      $('#konacha #zonk').module(modularity.Module)
+      window.alert.should.have.been.called
 
 
   describe 'event handling', ->
 
-    # Variables that should be accessible in both the beforeEach block and the tests.
     module = null
     mockContainer = null
 
     beforeEach ->
-      mockContainer = $('#test #module_container')
+      mockContainer = $('#konacha #module_container')
       module = new TestModule(mockContainer)
-      spyOn window, 'alert'
-
 
     describe 'bind_event', ->
 
       beforeEach ->
-        spyOn mockContainer, 'bind'
+        sinon.spy mockContainer, 'bind'
 
       it 'binds the given custom jQuery event type and the given callback to the container', ->
         myCallback = ->
         module.bind_event 'myEventType', myCallback
-        expect(mockContainer.bind).toHaveBeenCalledWith('myEventType', myCallback)
-        expect(window.alert).not.toHaveBeenCalled()
+        mockContainer.bind.should.have.been.called
+        mockContainer.bind.args[0][0].should.equal 'myEventType'
+        mockContainer.bind.args[0][1].should.equal myCallback
+        window.alert.should.not.have.been.called
 
       it "throws an error if no parameters are given", ->
         module.bind_event()
-        expect(window.alert).toHaveBeenCalled()
-        expect(mockContainer.bind).not.toHaveBeenCalled()
+        window.alert.should.have.been.called
+        mockContainer.bind.should.not.have.been.called
 
       it "throws an error if the given event type doesn't exist", ->
         module.bind_event undefined, ->
-        expect(window.alert).toHaveBeenCalled()
-        expect(mockContainer.bind).not.toHaveBeenCalled()
+        window.alert.should.have.been.called
+        mockContainer.bind.should.not.have.been.called
 
       it 'throws an error if the given event type is not a string', ->
         module.bind_event {}, ->
-        expect(window.alert).toHaveBeenCalled()
-        expect(mockContainer.bind).not.toHaveBeenCalled()
+        window.alert.should.have.been.called
+        mockContainer.bind.should.not.have.been.called
 
       it "throws an error if the given callback doesn't exist", ->
         module.bind_event '123'
-        expect(window.alert).toHaveBeenCalled()
-        expect(mockContainer.bind).not.toHaveBeenCalled()
+        window.alert.should.have.been.called
+        mockContainer.bind.should.not.have.been.called
 
       it 'throws an error if the given callback is not a function', ->
         module.bind_event '123', {}
-        expect(window.alert).toHaveBeenCalled()
-        expect(mockContainer.bind).not.toHaveBeenCalled()
+        window.alert.should.have.been.called
+        mockContainer.bind.should.not.have.been.called
 
 
     describe 'fire_event', ->
 
       beforeEach ->
-        spyOn mockContainer, 'trigger'
+        sinon.spy mockContainer, 'trigger'
 
       it 'triggers a custom jQuery event with the given event type on the container object', ->
         module.fire_event 'event type', 'event data'
-        expect(mockContainer.trigger).toHaveBeenCalledWith('event type', 'event data')
+        mockContainer.trigger.should.have.been.called
+        mockContainer.trigger.args[0][0].should.equal 'event type'
+        mockContainer.trigger.args[0][1].should.equal 'event data'
 
       describe 'when no payload is given', ->
         it 'provides an empty object as payload', ->
           module.fire_event 'event type'
-          expect(mockContainer.trigger).toHaveBeenCalled()
-          expect(mockContainer.trigger.argsForCall[0][1]).toEqual({})
+          mockContainer.trigger.should.have.been.called
+          mockContainer.trigger.args[0][1].should.eql({})
 
         it "doesn't change the original payload variable", ->
           data = undefined
           module.fire_event 'event type', data
-          expect(data).toBeUndefined
+          expect(data).to.be.undefined
 
       it 'provides 0 as payload if 0 is given', ->
         module.fire_event 'event type', 0
-        expect(mockContainer.trigger).toHaveBeenCalled()
-        expect(mockContainer.trigger.argsForCall[0][1]).toEqual(0)
+        mockContainer.trigger.should.have.been.called
+        mockContainer.trigger.args[0][1].should.equal(0)
 
       it 'throws an error if the given event type is not a string', ->
         module.fire_event {}
-        expect(mockContainer.trigger).not.toHaveBeenCalled()
-        expect(window.alert).toHaveBeenCalled()
+        mockContainer.trigger.should.not.have.been.called
+        window.alert.should.have.been.called
 
 
     describe 'global events', ->
 
-      # Variables that should be accessible in both the beforeEach block and the tests.
       mockGlobalContainer = null
-
       beforeEach ->
         mockGlobalContainer = $('#test #module_container')
-        spyOn(modularity, 'global_event_container').andReturn(mockGlobalContainer)
+        sinon.stub(modularity, 'global_event_container').returns(mockGlobalContainer)
+
+      afterEach ->
+        modularity.global_event_container.restore()
+
 
       describe 'bind_global_event', ->
 
         beforeEach ->
-          spyOn mockGlobalContainer, 'bind'
+          sinon.spy mockGlobalContainer, 'bind'
+
+        afterEach ->
+          mockGlobalContainer.bind.restore()
 
         it 'binds the given event type and callback method to the global event container', ->
           callback = ->
           modularity.bind_global_event '123', callback
-          expect(mockGlobalContainer.bind).toHaveBeenCalledWith('123', callback)
+          mockGlobalContainer.bind.should.have.been.called
+          mockGlobalContainer.bind.args[0][0].should.equal '123'
+          mockGlobalContainer.bind.args[0][1].should.equal callback
 
         it "throws an error if no parameters are given", ->
           modularity.bind_global_event()
-          expect(window.alert).toHaveBeenCalled()
-          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+          window.alert.should.have.been.called
+          mockGlobalContainer.bind.should.not.have.been.called
 
         it "throws an error if the given event type doesn't exist", ->
           modularity.bind_global_event undefined, ->
-          expect(window.alert).toHaveBeenCalled()
-          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+          window.alert.should.have.been.called
+          mockGlobalContainer.bind.should.not.have.been.called
 
         it 'throws an error if the given event type is not a string', ->
           modularity.bind_global_event {}, ->
-          expect(window.alert).toHaveBeenCalled()
-          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+          window.alert.should.have.been.called
+          mockGlobalContainer.bind.should.not.have.been.called
 
         it "throws an error if the given callback doesn't exist", ->
           modularity.bind_global_event '123'
-          expect(window.alert).toHaveBeenCalled()
-          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+          window.alert.should.have.been.called
+          mockGlobalContainer.bind.should.not.have.been.called
 
         it 'throws an error if the given callback is not a function', ->
           modularity.bind_global_event '123', {}
-          expect(window.alert).toHaveBeenCalled()
-          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+          window.alert.should.have.been.called
+          mockGlobalContainer.bind.should.not.have.been.called
 
 
       describe 'fire_global_event', ->
 
         beforeEach ->
-          spyOn mockGlobalContainer, 'trigger'
+          sinon.spy mockGlobalContainer, 'trigger'
+
+        afterEach ->
+          mockGlobalContainer.trigger.restore()
+
 
         it 'triggers a custom jQuery event with the given event type on the global event container object', ->
           modularity.fire_global_event 'event type', 'event data'
-          expect(mockGlobalContainer.trigger).toHaveBeenCalledWith('event type', 'event data')
+          mockGlobalContainer.trigger.should.have.been.called
+          mockGlobalContainer.trigger.args[0][0].should.equal 'event type'
+          mockGlobalContainer.trigger.args[0][1].should.equal 'event data'
 
         describe 'when no payload is given', ->
           it 'provides an empty object as payload', ->
             modularity.fire_global_event 'event type'
-            expect(mockGlobalContainer.trigger).toHaveBeenCalled()
-            expect(mockGlobalContainer.trigger.argsForCall[0][1]).toEqual({})
+            mockGlobalContainer.trigger.should.have.been.called
+            mockGlobalContainer.trigger.args[0][1].should.eql({})
 
           it "doesn't change the original payload variable", ->
             data = undefined
             modularity.fire_global_event 'event type', data
-            expect(data).toBeUndefined
+            expect(data).to.equal.undefined
 
         it 'provides 0 as payload if 0 is given', ->
           modularity.fire_global_event 'event type', 0
-          expect(mockGlobalContainer.trigger).toHaveBeenCalled()
-          expect(mockGlobalContainer.trigger.argsForCall[0][1]).toEqual(0)
+          mockGlobalContainer.trigger.should.have.been.called
+          mockGlobalContainer.trigger.args[0][1].should.equal(0)
 
         it 'throws an error if the given event type is not a string', ->
           modularity.fire_global_event {}
-          expect(mockGlobalContainer.trigger).not.toHaveBeenCalled()
-          expect(window.alert).toHaveBeenCalled()
+          mockGlobalContainer.trigger.should.not.have.been.called
+          window.alert.should.have.been.called
 
 
   describe 'mixins', ->
@@ -277,35 +280,41 @@ describe 'modularity', ->
         @mixin myMixin
 
 
-
     it 'adds all methods from the mixin object to the class prototype', ->
       instance = new Test('testing')
-      expect(typeof instance.method1).toBe("function")
+      instance.method1.should.be.a("function")
 
 
     it 'calls the proper mixin method when calling from the implementing module', ->
-      spyOn(myMixin, 'method1')
-      spyOn(myMixin, 'method2')
+      sinon.spy myMixin, 'method1'
+      sinon.spy myMixin, 'method2'
       instance = new Test('testing')
       instance.method1()
-      expect(myMixin.method1).toHaveBeenCalled()
-      expect(myMixin.method2).not.toHaveBeenCalled()
+      myMixin.method1.should.have.been.called
+      myMixin.method2.should.not.have.been.called
+      myMixin.method1.restore()
+      myMixin.method2.restore()
 
     it 'calls the mixin with the proper paramaters', ->
-      spyOn(myMixin, 'method1')
+      sinon.spy myMixin, 'method1'
       instance = new Test('testing')
       instance.method1("arg1", "arg2")
-      expect(myMixin.method1).toHaveBeenCalledWith("arg1", "arg2")
+      myMixin.method1.should.have.been.calledWith("arg1", "arg2")
+      myMixin.method1.restore()
 
 
     it 'calls the constructor of the mixin', ->
-      spyOn(myMixin, 'constructor')
+      sinon.spy myMixin, 'constructor'
       instance = new Test('testing')
-      expect(myMixin.constructor).toHaveBeenCalled()
+      myMixin.constructor.should.have.been.called
 
 
-    it 'calls the constructor with the this pointing to the instance', ->
+    it 'calls the constructor with the this object pointing to the instance', ->
       instance = new Test('testing')
-      expect(recordedSelf).toBe(instance)
+      recordedSelf.should.equal instance
+
+    it "can handle mixins that don't define a constructor"
+
+    it "shows an error message if the given mixin is undefined"
 
-    xit 'provides arguments to the @mixin method to the mixin constructor'
+    it 'provides arguments to the @mixin method to the mixin constructor'