fidgit 0.2.4 → 0.2.5

data/lib/fidgit/states/message_dialog.rb

@@ -1,61 +1,61 @@
-
-module Fidgit
-  # A simple dialog that manages a message with a set of buttons beneath it.
-  class MessageDialog < DialogState
-    VALID_TYPES = [:ok, :ok_cancel, :yes_no, :yes_no_cancel, :quit_cancel, :quit_save_cancel]
-
-    attr_reader :type
-
-    # @param [String] message
-    #
-    # @option options [Symbol] :type (:ok) One from :ok, :ok_cancel, :yes_no, :yes_no_cancel, :quit_cancel or :quit_save_cancel
-    # @option options [String] :ok_text ("OK")
-    # @option options [String] :yes_text ("Yes")
-    # @option options [String] :no_text ("No")
-    # @option options [String] :cancel_text ("Cancel")
-    # @option options [String] :save_text ("Save")
-    # @option options [String] :quit_text ("Quit")
-    # @option options [Boolean] :show (true) Whether to show the message immediately (otherwise need to use #show later).
-    #
-    # @yield when the dialog is closed.
-    # @yieldparam [Symbol] result :ok, :yes, :no, :quit, :save or :cancel, depending on the button pressed.
-    def initialize(message, options = {}, &block)
-      options = {
-        type: :ok,
-        ok_text: "OK",
-        yes_text: "Yes",
-        no_text: "No",
-        quit_text: "Quit",
-        save_text: "Save",
-        cancel_text: "Cancel",
-        show: true,
-        background_color: DEFAULT_BACKGROUND_COLOR,
-        border_color: DEFAULT_BORDER_COLOR,
-        width: $window.width / 2
-      }.merge! options
-
-      @type = options[:type]
-      raise ArgumentError, ":type must be one of #{VALID_TYPES}, not #{@type}" unless VALID_TYPES.include? @type
-
-      super(options)
-
-      # Dialog is forced to the centre.
-      options[:align_h] = options[:align_v] = :center
-
-      vertical options do
-        text_area(text: message, enabled: false, width: options[:width] - padding_left - padding_right)
-
-        horizontal align_h: :center do
-          @type.to_s.split('_').each do |type|
-            button(options[:"#{type}_text"]) do
-              hide
-              block.call type.to_sym if block
-            end
-          end
-        end
-      end
-
-      show if options[:show]
-    end
-  end
+
+module Fidgit
+  # A simple dialog that manages a message with a set of buttons beneath it.
+  class MessageDialog < DialogState
+    VALID_TYPES = [:ok, :ok_cancel, :yes_no, :yes_no_cancel, :quit_cancel, :quit_save_cancel]
+
+    attr_reader :type
+
+    # @param [String] message
+    #
+    # @option options [Symbol] :type (:ok) One from :ok, :ok_cancel, :yes_no, :yes_no_cancel, :quit_cancel or :quit_save_cancel
+    # @option options [String] :ok_text ("OK")
+    # @option options [String] :yes_text ("Yes")
+    # @option options [String] :no_text ("No")
+    # @option options [String] :cancel_text ("Cancel")
+    # @option options [String] :save_text ("Save")
+    # @option options [String] :quit_text ("Quit")
+    # @option options [Boolean] :show (true) Whether to show the message immediately (otherwise need to use #show later).
+    #
+    # @yield when the dialog is closed.
+    # @yieldparam [Symbol] result :ok, :yes, :no, :quit, :save or :cancel, depending on the button pressed.
+    def initialize(message, options = {}, &block)
+      options = {
+        type: :ok,
+        ok_text: "OK",
+        yes_text: "Yes",
+        no_text: "No",
+        quit_text: "Quit",
+        save_text: "Save",
+        cancel_text: "Cancel",
+        show: true,
+        background_color: DEFAULT_BACKGROUND_COLOR,
+        border_color: DEFAULT_BORDER_COLOR,
+        width: $window.width / 2
+      }.merge! options
+
+      @type = options[:type]
+      raise ArgumentError, ":type must be one of #{VALID_TYPES}, not #{@type}" unless VALID_TYPES.include? @type
+
+      super(options)
+
+      # Dialog is forced to the centre.
+      options[:align_h] = options[:align_v] = :center
+
+      vertical options do
+        text_area(text: message, enabled: false, width: options[:width] - padding_left - padding_right)
+
+        horizontal align_h: :center do
+          @type.to_s.split('_').each do |type|
+            button(options[:"#{type}_text"]) do
+              hide
+              block.call type.to_sym if block
+            end
+          end
+        end
+      end
+
+      show if options[:show]
+    end
+  end
 end

data/lib/fidgit/version.rb

@@ -1,5 +1,5 @@
-# encoding: UTF-8
-
-module Fidgit
-  VERSION = '0.2.4'
+# encoding: UTF-8
+
+module Fidgit
+  VERSION = '0.2.5'
 end

data/lib/fidgit/window.rb

@@ -1,19 +1,19 @@
-# encoding: utf-8
-
-module Fidgit
-  module Window
-
-    def self.included(base)
-      base.send :include, Methods
-    end
-
-    module Methods
-
-      def close
-        super
-        GuiState.clear
-      end
-    end
-    
-  end
-end
+# encoding: utf-8
+
+module Fidgit
+  module Window
+
+    def self.included(base)
+      base.send :include, Methods
+    end
+
+    module Methods
+
+      def close
+        super
+        GuiState.clear
+      end
+    end
+    
+  end
+end

data/spec/fidgit/elements/helpers/helper.rb

@@ -1,3 +1,3 @@
-require "rspec"
-
+require "rspec"
+
 require_relative File.join(File.dirname(__FILE__), "..", "..", "..", "..", "lib", "fidgit")

data/spec/fidgit/elements/helpers/tex_play_helper.rb

@@ -1,9 +1,9 @@
-require 'texplay'
-
-module Gosu
-  class Image
-    def self.create(width, height, options = {})
-      TexPlay.create_image($window, width, height, options)
-    end
-  end
+require 'texplay'
+
+module Gosu
+  class Image
+    def self.create(width, height, options = {})
+      TexPlay.create_image($window, width, height, options)
+    end
+  end
 end

data/spec/fidgit/elements/image_frame_spec.rb

@@ -1,69 +1,69 @@
-require_relative 'helpers/helper'
-require_relative 'helpers/tex_play_helper'
-
-require 'fidgit'
-
-def check_thumbnail_is_square
-  {square: [10, 10], tall: [5, 12], wide: [6, 5]}.each_pair do |type, dimensions|
-    context "with a #{type} image" do
-      it "should be square and just large enough to contain the image" do
-        subject = described_class.new(Gosu::Image.create(*dimensions), thumbnail: true)
-        subject.width.should equal dimensions.max
-        subject.height.should equal dimensions.max
-      end
-    end
-  end
-end
-
-def check_image_dimensions
-  {square: [10, 10], tall: [5, 12], wide: [6, 5]}.each_pair do |type, dimensions|
-    context "with a #{type} image" do
-      it "should be just large enough to contain the image" do
-        subject = described_class.new(Gosu::Image.create(*dimensions))
-        subject.width.should equal dimensions.first
-        subject.height.should equal dimensions.last
-      end
-    end
-  end
-end
-
-module Fidgit
-  describe ImageFrame do
-    before :all do
-      $window = Chingu::Window.new(100, 100, false) unless $window
-    end
-
-    before :each do
-      @image = Gosu::Image.create(10, 10)
-    end
-
-    subject { described_class.new(@image) }
-
-    describe '#image' do
-      it "should have the image set" do
-        subject.image.should be @image
-      end
-    end
-
-    describe '#width and #height' do
-      check_image_dimensions
-    end
-
-    describe "Thumbnails" do
-      subject { described_class.new(@image, thumbnail: true) }
-
-      describe '#image=' do
-        it "should update the height and width" do
-          image = Gosu::Image.create(8, 2)
-          subject.image = image
-          subject.height.should equal 8
-          subject.width.should equal 8
-        end
-      end
-
-      describe '#width and #height' do
-        check_thumbnail_is_square
-      end
-    end
-  end
+require_relative 'helpers/helper'
+require_relative 'helpers/tex_play_helper'
+
+require 'fidgit'
+
+def check_thumbnail_is_square
+  {square: [10, 10], tall: [5, 12], wide: [6, 5]}.each_pair do |type, dimensions|
+    context "with a #{type} image" do
+      it "should be square and just large enough to contain the image" do
+        subject = described_class.new(Gosu::Image.create(*dimensions), thumbnail: true)
+        subject.width.should equal dimensions.max
+        subject.height.should equal dimensions.max
+      end
+    end
+  end
+end
+
+def check_image_dimensions
+  {square: [10, 10], tall: [5, 12], wide: [6, 5]}.each_pair do |type, dimensions|
+    context "with a #{type} image" do
+      it "should be just large enough to contain the image" do
+        subject = described_class.new(Gosu::Image.create(*dimensions))
+        subject.width.should equal dimensions.first
+        subject.height.should equal dimensions.last
+      end
+    end
+  end
+end
+
+module Fidgit
+  describe ImageFrame do
+    before :all do
+      $window = Chingu::Window.new(100, 100, false) unless $window
+    end
+
+    before :each do
+      @image = Gosu::Image.create(10, 10)
+    end
+
+    subject { described_class.new(@image) }
+
+    describe '#image' do
+      it "should have the image set" do
+        subject.image.should be @image
+      end
+    end
+
+    describe '#width and #height' do
+      check_image_dimensions
+    end
+
+    describe "Thumbnails" do
+      subject { described_class.new(@image, thumbnail: true) }
+
+      describe '#image=' do
+        it "should update the height and width" do
+          image = Gosu::Image.create(8, 2)
+          subject.image = image
+          subject.height.should equal 8
+          subject.width.should equal 8
+        end
+      end
+
+      describe '#width and #height' do
+        check_thumbnail_is_square
+      end
+    end
+  end
 end

data/spec/fidgit/elements/label_spec.rb

@@ -1,37 +1,37 @@
-require_relative "helpers/helper"
-
-include Fidgit
-
-describe Label do
-  before :all do
-    $window = Chingu::Window.new(100, 100, false) unless $window
-  end
-
-  context "with default parameters" do
-    subject { Label.new( "Hello world!") }
-
-    it "should have text value set" do
-      subject.text.should eq "Hello world!"
-    end
-
-    it "should have white text" do
-      subject.color.should eq Gosu::Color.rgb(255, 255, 255)
-    end
-
-    it "should have a transparent background" do
-      subject.background_color.should be_transparent
-    end
-
-    it "should have a transparent border" do
-      subject.border_color.should be_transparent
-    end
-
-    it "should be enabled" do
-      subject.should be_enabled
-    end
-
-    it "should not have an image" do
-      subject.icon.should be_nil
-    end
-  end
+require_relative "helpers/helper"
+
+include Fidgit
+
+describe Label do
+  before :all do
+    $window = Chingu::Window.new(100, 100, false) unless $window
+  end
+
+  context "with default parameters" do
+    subject { Label.new( "Hello world!") }
+
+    it "should have text value set" do
+      subject.text.should eq "Hello world!"
+    end
+
+    it "should have white text" do
+      subject.color.should eq Gosu::Color.rgb(255, 255, 255)
+    end
+
+    it "should have a transparent background" do
+      subject.background_color.should be_transparent
+    end
+
+    it "should have a transparent border" do
+      subject.border_color.should be_transparent
+    end
+
+    it "should be enabled" do
+      subject.should be_enabled
+    end
+
+    it "should not have an image" do
+      subject.icon.should be_nil
+    end
+  end
 end

data/spec/fidgit/event_spec.rb

@@ -1,210 +1,210 @@
-require_relative 'helpers/helper'
-
-require 'event'
-
-module Fidgit
-  describe Event do
-    before :each do
-      class Test
-        include Event
-      end
-    end
-
-    after :each do
-      Fidgit.send :remove_const, :Test
-    end
-
-    subject { Test }
-
-    describe "events" do
-      it "should initially be empty" do
-        subject.events.should be_empty
-      end
-    end
-
-    describe "event" do
-      it "should add the event to the list of events handled" do
-        subject.event :frog
-        subject.events.should include :frog
-      end
-
-      it "should inherit parent's events and be able to add more" do
-        Test.event :frog
-        class Test2 < Test; end
-        Test2.event :fish
-        Test2.events.should include :frog
-        Test2.events.should include :fish
-      end
-    end
-
-    context "When included into a class that is instanced" do
-      subject { Test.event :frog; Test.new }
-
-      describe "#subscribe" do
-        it "should add a handler as a block" do
-          subject.subscribe(:frog) { puts "hello" }
-        end
-
-        it "should fail if the event name isn't handled by this object" do
-          ->{ subject.subscribe(:unhandled_event) {} }.should raise_error ArgumentError
-        end
-
-        it "should add a handler as a method" do
-          subject.stub! :handler
-          subject.subscribe(:frog, subject.method(:handler))
-        end
-
-        it "should fail if neither a method or a block is passed" do
-          ->{ subject.subscribe(:frog) }.should raise_error ArgumentError
-        end
-
-        it "should fail if both a method and a block is passed" do
-          subject.stub! :handler
-          ->{ subject.subscribe(:frog, subject.method(:handler)) { } }.should raise_error ArgumentError
-        end
-
-        it "should return a Subscription" do
-          handler = proc {}
-          result = subject.subscribe(:frog, &handler)
-          result.should be_a Fidgit::Event::Subscription
-          result.handler.should be handler
-          result.publisher.should be subject
-          result.event.should equal :frog
-        end
-
-        it "should return a Subscription that can use Subscription#unsubscribe" do
-          handler_ran = false
-          subscription = subject.subscribe(:frog) { handler_ran = true }
-          subscription.unsubscribe
-          subject.publish :frog
-          handler_ran.should be_false
-        end
-      end
-
-      describe "#unsubscribe" do
-        it "should accept a Subscription" do
-          handler_ran = false
-          subscription = subject.subscribe(:frog) { handler_ran = true }
-          subject.unsubscribe subscription
-          subject.publish :frog
-          handler_ran.should be_false
-        end
-
-        it "should accept a handler" do
-          handler_ran = false
-          handler = proc { handler_ran = true }
-          subject.subscribe(:frog, &handler)
-          subject.unsubscribe handler
-          subject.publish :frog
-          handler_ran.should be_false
-        end
-
-        it "should accept an event and handler" do
-          handler_ran = false
-          handler = proc { handler_ran = true }
-          subject.subscribe(:frog, &handler)
-          subject.unsubscribe :frog, handler
-          subject.publish :frog
-          handler_ran.should be_false
-        end
-
-        it "should require 1..2 arguments" do
-          ->{ subject.unsubscribe }.should raise_error ArgumentError
-          ->{ subject.unsubscribe 1, 2, 3 }.should raise_error ArgumentError
-        end
-
-        it "should fail with bad types" do
-          ->{ subject.unsubscribe 1 }.should raise_error TypeError
-          ->{ subject.unsubscribe 1, ->{} }.should raise_error TypeError
-          ->{ subject.unsubscribe :event, 2 }.should raise_error TypeError
-        end
-
-        it "should fail if passed a Subscription to another object" do
-          subscription = Fidgit::Event::Subscription.new(Object.new.extend(Fidgit::Event), :event, proc {})
-          ->{ subject.unsubscribe subscription }.should raise_error ArgumentError
-        end
-      end
-
-      describe "#publish" do
-        it "should return nil if there are no handlers" do
-          subject.publish(:frog).should be_nil
-        end
-
-        it "should return nil if there are no handlers that handle the event" do
-          subject.should_receive(:frog).with(subject)
-          subject.should_receive(:handler).with(subject)
-          subject.subscribe(:frog, subject.method(:handler))
-          subject.publish(:frog).should be_nil
-        end
-
-        it "should return :handled if a manual handler handled the event and not call other handlers" do
-          subject.should_not_receive(:handler1)
-          subject.should_receive(:handler2).with(subject).and_return(:handled)
-          subject.subscribe(:frog, subject.method(:handler1))
-          subject.subscribe(:frog, subject.method(:handler2))
-          subject.publish(:frog).should == :handled
-        end
-
-        it "should return :handled if an automatic handler handled the event and not call other handlers" do
-          subject.should_receive(:frog).with(subject).and_return(:handled)
-          subject.should_not_receive(:handler2)
-          subject.subscribe(:frog, subject.method(:handler2))
-          subject.publish(:frog).should == :handled
-        end
-
-        it "should pass the object as the first parameter" do
-          subject.should_receive(:handler).with(subject)
-          subject.subscribe(:frog, subject.method(:handler))
-          subject.publish :frog
-        end
-
-        it "should call all the handlers, once each" do
-          subject.should_receive(:handler1).with(subject)
-          subject.should_receive(:handler2).with(subject)
-          subject.subscribe(:frog, subject.method(:handler1))
-          subject.subscribe(:frog, subject.method(:handler2))
-          subject.publish(:frog).should be_nil
-        end
-
-        it "should pass parameters passed to it" do
-          subject.should_receive(:handler).with(subject, 1, 2)
-          subject.subscribe(:frog, subject.method(:handler))
-          subject.publish(:frog, 1, 2).should be_nil
-        end
-
-        it "should do nothing if the subject is disabled" do
-          subject.should_receive(:enabled?).and_return(false)
-          subject.should_not_receive(:handler)
-          subject.subscribe(:frog, subject.method(:handler))
-          subject.publish(:frog, 1, 2).should be_nil
-        end
-
-        it "should act normally if the subject is enabled" do
-          subject.should_receive(:enabled?).and_return(true)
-          subject.should_receive(:handler)
-          subject.subscribe(:frog, subject.method(:handler))
-          subject.publish(:frog, 1, 2).should be_nil
-        end
-
-        it "should only call the handlers requested" do
-          Test.event :fish
-
-          subject.should_receive(:handler1).with(subject)
-          subject.should_not_receive(:handler2)
-          subject.subscribe(:frog, subject.method(:handler1))
-          subject.subscribe(:fish, subject.method(:handler2))
-          subject.publish(:frog).should be_nil
-        end
-
-        it "should automatically call a method on the publisher if it exists" do
-          subject.should_receive(:frog).with(subject)
-          subject.publish(:frog).should be_nil
-        end
-
-        it "should fail if the event name isn't handled by this object" do
-          ->{ subject.publish(:unhandled_event) }.should raise_error ArgumentError
-        end
-      end
-    end
-  end
+require_relative 'helpers/helper'
+
+require 'event'
+
+module Fidgit
+  describe Event do
+    before :each do
+      class Test
+        include Event
+      end
+    end
+
+    after :each do
+      Fidgit.send :remove_const, :Test
+    end
+
+    subject { Test }
+
+    describe "events" do
+      it "should initially be empty" do
+        subject.events.should be_empty
+      end
+    end
+
+    describe "event" do
+      it "should add the event to the list of events handled" do
+        subject.event :frog
+        subject.events.should include :frog
+      end
+
+      it "should inherit parent's events and be able to add more" do
+        Test.event :frog
+        class Test2 < Test; end
+        Test2.event :fish
+        Test2.events.should include :frog
+        Test2.events.should include :fish
+      end
+    end
+
+    context "When included into a class that is instanced" do
+      subject { Test.event :frog; Test.new }
+
+      describe "#subscribe" do
+        it "should add a handler as a block" do
+          subject.subscribe(:frog) { puts "hello" }
+        end
+
+        it "should fail if the event name isn't handled by this object" do
+          ->{ subject.subscribe(:unhandled_event) {} }.should raise_error ArgumentError
+        end
+
+        it "should add a handler as a method" do
+          subject.stub! :handler
+          subject.subscribe(:frog, subject.method(:handler))
+        end
+
+        it "should fail if neither a method or a block is passed" do
+          ->{ subject.subscribe(:frog) }.should raise_error ArgumentError
+        end
+
+        it "should fail if both a method and a block is passed" do
+          subject.stub! :handler
+          ->{ subject.subscribe(:frog, subject.method(:handler)) { } }.should raise_error ArgumentError
+        end
+
+        it "should return a Subscription" do
+          handler = proc {}
+          result = subject.subscribe(:frog, &handler)
+          result.should be_a Fidgit::Event::Subscription
+          result.handler.should be handler
+          result.publisher.should be subject
+          result.event.should equal :frog
+        end
+
+        it "should return a Subscription that can use Subscription#unsubscribe" do
+          handler_ran = false
+          subscription = subject.subscribe(:frog) { handler_ran = true }
+          subscription.unsubscribe
+          subject.publish :frog
+          handler_ran.should be_false
+        end
+      end
+
+      describe "#unsubscribe" do
+        it "should accept a Subscription" do
+          handler_ran = false
+          subscription = subject.subscribe(:frog) { handler_ran = true }
+          subject.unsubscribe subscription
+          subject.publish :frog
+          handler_ran.should be_false
+        end
+
+        it "should accept a handler" do
+          handler_ran = false
+          handler = proc { handler_ran = true }
+          subject.subscribe(:frog, &handler)
+          subject.unsubscribe handler
+          subject.publish :frog
+          handler_ran.should be_false
+        end
+
+        it "should accept an event and handler" do
+          handler_ran = false
+          handler = proc { handler_ran = true }
+          subject.subscribe(:frog, &handler)
+          subject.unsubscribe :frog, handler
+          subject.publish :frog
+          handler_ran.should be_false
+        end
+
+        it "should require 1..2 arguments" do
+          ->{ subject.unsubscribe }.should raise_error ArgumentError
+          ->{ subject.unsubscribe 1, 2, 3 }.should raise_error ArgumentError
+        end
+
+        it "should fail with bad types" do
+          ->{ subject.unsubscribe 1 }.should raise_error TypeError
+          ->{ subject.unsubscribe 1, ->{} }.should raise_error TypeError
+          ->{ subject.unsubscribe :event, 2 }.should raise_error TypeError
+        end
+
+        it "should fail if passed a Subscription to another object" do
+          subscription = Fidgit::Event::Subscription.new(Object.new.extend(Fidgit::Event), :event, proc {})
+          ->{ subject.unsubscribe subscription }.should raise_error ArgumentError
+        end
+      end
+
+      describe "#publish" do
+        it "should return nil if there are no handlers" do
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should return nil if there are no handlers that handle the event" do
+          subject.should_receive(:frog).with(subject)
+          subject.should_receive(:handler).with(subject)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should return :handled if a manual handler handled the event and not call other handlers" do
+          subject.should_not_receive(:handler1)
+          subject.should_receive(:handler2).with(subject).and_return(:handled)
+          subject.subscribe(:frog, subject.method(:handler1))
+          subject.subscribe(:frog, subject.method(:handler2))
+          subject.publish(:frog).should == :handled
+        end
+
+        it "should return :handled if an automatic handler handled the event and not call other handlers" do
+          subject.should_receive(:frog).with(subject).and_return(:handled)
+          subject.should_not_receive(:handler2)
+          subject.subscribe(:frog, subject.method(:handler2))
+          subject.publish(:frog).should == :handled
+        end
+
+        it "should pass the object as the first parameter" do
+          subject.should_receive(:handler).with(subject)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish :frog
+        end
+
+        it "should call all the handlers, once each" do
+          subject.should_receive(:handler1).with(subject)
+          subject.should_receive(:handler2).with(subject)
+          subject.subscribe(:frog, subject.method(:handler1))
+          subject.subscribe(:frog, subject.method(:handler2))
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should pass parameters passed to it" do
+          subject.should_receive(:handler).with(subject, 1, 2)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish(:frog, 1, 2).should be_nil
+        end
+
+        it "should do nothing if the subject is disabled" do
+          subject.should_receive(:enabled?).and_return(false)
+          subject.should_not_receive(:handler)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish(:frog, 1, 2).should be_nil
+        end
+
+        it "should act normally if the subject is enabled" do
+          subject.should_receive(:enabled?).and_return(true)
+          subject.should_receive(:handler)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish(:frog, 1, 2).should be_nil
+        end
+
+        it "should only call the handlers requested" do
+          Test.event :fish
+
+          subject.should_receive(:handler1).with(subject)
+          subject.should_not_receive(:handler2)
+          subject.subscribe(:frog, subject.method(:handler1))
+          subject.subscribe(:fish, subject.method(:handler2))
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should automatically call a method on the publisher if it exists" do
+          subject.should_receive(:frog).with(subject)
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should fail if the event name isn't handled by this object" do
+          ->{ subject.publish(:unhandled_event) }.should raise_error ArgumentError
+        end
+      end
+    end
+  end
 end