modularity-rails 0.2.0 → 0.3.0

data/lib/modularity-rails/version.rb

@@ -1,3 +1,3 @@
 module ModularityRails
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/javascripts/modularity_spec.coffee

@@ -13,7 +13,7 @@ loadCS = (url, callback) ->
 # Helper method to load the modularity library before the tests.
 describe 'modularity loader', ->
   it 'loading Modularity library ...', ->
-    loadCS '/vendor/assets/javascripts/modularity.js.coffee'
+    loadCS '/vendor/assets/javascripts/modularity.js.coffee?'+(new Date()).getTime()
 
 
 describe 'modularity', ->
@@ -56,29 +56,35 @@ describe 'modularity', ->
       module = new Module('testing')
 
     it 'shows an alert with the given message if the given condition is false', ->
-      module.assert false, 'Message'
+      Module.assert false, 'Message'
       expect(alert).toHaveBeenCalledWith("Message")
 
     it 'fails when the condition is null', ->
-      module.assert null, 'Message'
+      Module.assert null, 'Message'
       expect(alert).toHaveBeenCalledWith("Message")
 
     it 'fails when the condition is undefined', ->
-      module.assert undefined, 'Message'
+      Module.assert undefined, 'Message'
       expect(alert).toHaveBeenCalledWith("Message")
 
     it 'fails when the condition is an empty array', ->
-      module.assert [], 'Message'
+      Module.assert [], 'Message'
       expect(alert).toHaveBeenCalledWith("Message")
 
     it 'fails when the condition is an empty string', ->
-      module.assert '', 'Message'
+      Module.assert '', 'Message'
       expect(alert).toHaveBeenCalledWith("Message")
 
     it 'passes when the condition is a string', ->
-      module.assert '123', 'Message'
+      Module.assert '123', 'Message'
       expect(alert).not.toHaveBeenCalled()
 
+    it "returns false if the condition doesn't pass", ->
+      expect(Module.assert(false)).toBeFalsy()
+
+    it "returns true if the condition passes", ->
+      expect(Module.assert('123')).toBeTruthy()
+
 
   describe 'jQuery Integration', ->
 
@@ -101,3 +107,159 @@ describe 'modularity', ->
     it 'returns an error if the jQuery object is empty.', ->
       $('#zonk').module(Module)
       expect(alert).toHaveBeenCalled()
+
+
+  describe 'event handling', ->
+
+    # Variables that should be accessible in both the beforeEach block and the tests.
+    module = null
+    mockContainer = null
+
+    beforeEach ->
+      mockContainer = $('#module_container')
+      module = new Module(mockContainer)
+      spyOn window, 'alert'
+
+
+    describe 'bind_event', ->
+
+      beforeEach ->
+        spyOn 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()
+
+      it "throws an error if no parameters are given", ->
+        module.bind_event()
+        expect(window.alert).toHaveBeenCalled()
+        expect(mockContainer.bind).not.toHaveBeenCalled()
+
+      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()
+
+      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()
+
+      it "throws an error if the given callback doesn't exist", ->
+        module.bind_event '123'
+        expect(window.alert).toHaveBeenCalled()
+        expect(mockContainer.bind).not.toHaveBeenCalled()
+
+      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()
+
+
+    describe 'fire_event', ->
+
+      beforeEach ->
+        spyOn 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')
+
+      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({})
+
+        it "doesn't change the original payload variable", ->
+          data = undefined
+          module.fire_event 'event type', data
+          expect(data).toBeUndefined
+
+      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)
+
+      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()
+
+
+    describe 'global events', ->
+
+      # Variables that should be accessible in both the beforeEach block and the tests.
+      mockGlobalContainer = null
+
+      beforeEach ->
+        mockGlobalContainer = $('#module_container')
+        spyOn(Module, 'global_event_container').andReturn(mockGlobalContainer)
+
+      describe 'bind_global_event', ->
+
+        beforeEach ->
+          spyOn mockGlobalContainer, 'bind'
+
+        it 'binds the given event type and callback method to the global event container', ->
+          callback = ->
+          Module.bind_global_event '123', callback
+          expect(mockGlobalContainer.bind).toHaveBeenCalledWith('123', callback)
+
+        it "throws an error if no parameters are given", ->
+          Module.bind_global_event()
+          expect(window.alert).toHaveBeenCalled()
+          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+
+        it "throws an error if the given event type doesn't exist", ->
+          Module.bind_global_event undefined, ->
+          expect(window.alert).toHaveBeenCalled()
+          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+
+        it 'throws an error if the given event type is not a string', ->
+          Module.bind_global_event {}, ->
+          expect(window.alert).toHaveBeenCalled()
+          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+
+        it "throws an error if the given callback doesn't exist", ->
+          Module.bind_global_event '123'
+          expect(window.alert).toHaveBeenCalled()
+          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+
+        it 'throws an error if the given callback is not a function', ->
+          Module.bind_global_event '123', {}
+          expect(window.alert).toHaveBeenCalled()
+          expect(mockGlobalContainer.bind).not.toHaveBeenCalled()
+
+
+      describe 'fire_global_event', ->
+
+        beforeEach ->
+          spyOn mockGlobalContainer, 'trigger'
+
+        it 'triggers a custom jQuery event with the given event type on the global event container object', ->
+          Module.fire_global_event 'event type', 'event data'
+          expect(mockGlobalContainer.trigger).toHaveBeenCalledWith('event type', 'event data')
+
+        describe 'when no payload is given', ->
+          it 'provides an empty object as payload', ->
+            Module.fire_global_event 'event type'
+            expect(mockGlobalContainer.trigger).toHaveBeenCalled()
+            expect(mockGlobalContainer.trigger.argsForCall[0][1]).toEqual({})
+
+          it "doesn't change the original payload variable", ->
+            data = undefined
+            Module.fire_global_event 'event type', data
+            expect(data).toBeUndefined
+
+        it 'provides 0 as payload if 0 is given', ->
+          Module.fire_global_event 'event type', 0
+          expect(mockGlobalContainer.trigger).toHaveBeenCalled()
+          expect(mockGlobalContainer.trigger.argsForCall[0][1]).toEqual(0)
+
+        it 'throws an error if the given event type is not a string', ->
+          Module.fire_global_event {}
+          expect(mockGlobalContainer.trigger).not.toHaveBeenCalled()
+          expect(window.alert).toHaveBeenCalled()

data/vendor/assets/javascripts/modularity.js.coffee

@@ -16,38 +16,43 @@ class window.Module
 
   # Checks whether the given condition is true.
   # Shows an alert with the given message if not.
-  assert: (condition, message) ->
-    alert(message) unless condition?.length > 0
+  @assert: (condition, message) ->
+    condition_ok = condition?.length > 0
+    alert(message) unless condition_ok
+    condition_ok
 
   # MODULE EVENTS.
 
   # Calls the given function when this widget fires the given local event.
   bind_event: (event_type, callback) =>
-    @assert event_type, "Module.bind_event: parameter 'event_type' is empty"
+    return unless Module.assert event_type, "Module.bind_event: parameter 'event_type' is empty"
+    return alert "Module.bind_event: parameter 'callback' must be a function, #{callback} (#{typeof callback}) given." unless typeof callback == 'function'
     @container.bind event_type, callback
 
   # Fires the given local event with the given data payload.
   fire_event: (event_type, data) =>
-    @assert event_type, 'Module.fire_event: You must provide the event type to fire.'
-    @container.trigger event_type, data or {}
+    Module.assert event_type, 'Module.fire_event: You must provide the event type to fire.'
+    return alert("Module.fire_event: Event type must be a string, #{event_type} (#{typeof event_type}) given.") unless typeof event_type == 'string'
+    @container.trigger event_type, data ?= {}
 
 
   # GLOBAL EVENTS.
 
   # Subscribes to the given global event, 
   # i.e. calls the given function when the given global event type happens.
-  bind_global_event: (event_type, callback) =>
-    @assert event_type, "Module.bind_global_event: parameter 'event_type' is empty"
+  @bind_global_event: (event_type, callback) =>
+    return unless @assert event_type, "Module.bind_global_event: parameter 'event_type' is empty"
+    return alert "Module.bind_global_event: parameter 'callback' must be a function, #{callback} (#{typeof callback}) given." unless typeof callback == 'function'
     @global_event_container().bind event_type, callback
 
   # Fires the given global event with the given data payload.
-  fire_global_event: (event_type, data) =>
+  @fire_global_event: (event_type, data) =>
     @assert event_type, 'Module.fire_global_event: You must provide the event type to fire.'
-    @global_event_container().trigger event_type, data or []
+    return alert("Module.fire_global_event: Event type must be a string, #{event_type} (#{typeof event_type}) given.") unless typeof event_type == 'string'
+    @global_event_container().trigger event_type, data ?= []
 
   # Returns the DOM object that is used to fire global events on.
-  global_event_container: =>
-    @global_event_container_cache or= $(window)
+  @global_event_container: => @global_event_container_cache or= $(window)
 
 
 # jQuery integration for creating Modules.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: modularity-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70185851808700 !ruby/object:Gem::Requirement
+  requirement: &70292877992260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 3.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *70185851808700
+  version_requirements: *70292877992260
 - !ruby/object:Gem::Dependency
   name: capybara-webkit
-  requirement: &70185851807920 !ruby/object:Gem::Requirement
+  requirement: &70292877991380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70185851807920
+  version_requirements: *70292877991380
 - !ruby/object:Gem::Dependency
   name: evergreen
-  requirement: &70185851802840 !ruby/object:Gem::Requirement
+  requirement: &70292877990260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70185851802840
+  version_requirements: *70292877990260
 description: Description of ModularityRails.
 email:
 - kevin.goslar@gmail.com