apotomo 1.1.0 → 1.1.1

data/CHANGES.textile

@@ -1,3 +1,16 @@
+h2. 1.1.1
+
+h3. Additions
+  * You can now attach event handlers to other widgets simply by using the @:passing@ option: @responds_to_event :click, :passing => :root@.
+  * If you want to debug events, just include the (WIP) @apotomo/debugging@ file and watch your server output on the console.
+  
+h3. Changes
+  * @Widget.responds_to_event@ is inheritable now.
+  * The generator now places namespaced widgets into the correct sub-directories.
+
+h3. Removals
+  * Removed the alias @Widget.respond_to_event@, please use @Widget.responds_to_event@.
+
 h2. 1.1
 
 h3. Changes

data/apotomo.gemspec

@@ -20,9 +20,10 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   
   s.add_dependency "rails",   "~> 3.0"
-  s.add_dependency "cells",   "~> 3.5.4"
-  s.add_dependency "onfire",  "~> 0.1.2"
+  s.add_dependency "cells",   "~> 3.5.6"
+  s.add_dependency "onfire",  "~> 0.2.0"
   s.add_dependency "hooks",   "~> 0.1.3"
 
   s.add_development_dependency "shoulda"
+  s.add_development_dependency "slim"
 end

data/lib/apotomo/debugging.rb

@@ -0,0 +1,9 @@
+require "onfire/debugging"
+
+Apotomo::Event.class_eval do
+  include Onfire::Event::Debugging
+  
+  debug do |widget, event|
+    puts "#{widget.name}: #{event}"
+  end
+end

data/lib/apotomo/event.rb

@@ -2,8 +2,8 @@ module Apotomo
   # Events are created by Apotomo in #fire. They bubble up from their source to root and trigger
   # event handlers. 
   class Event < Onfire::Event
-    def _dump(depth)
-      raise "You're trying to serialize an instance of Apotomo::Event. Don't do that."
+    def to_s
+      "<Event :#{type} source=#{source.widget_id}>"
     end
     
     delegate :[], :to => :data

data/lib/apotomo/rails/controller_methods.rb

@@ -36,7 +36,7 @@ module Apotomo
         # Example:
         #   class PostsController < ApplicationController
         #     has_widgets do |root|
-        #       root << widget(:comments_widget, 'post-comments', :user => @current_user)
+        #       root << widget(:comments, :user => current_user)
         #     end
         def has_widgets(&block)
           has_widgets_blocks << block

data/lib/apotomo/version.rb

@@ -1,3 +1,3 @@
 module Apotomo
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
 end

data/lib/apotomo/widget/event_methods.rb

@@ -0,0 +1,122 @@
+require 'apotomo/invoke_event_handler'
+
+module Apotomo
+  # Event-related methods and onfire bridge for Widget.
+  module EventMethods
+    extend ActiveSupport::Concern
+    
+    included do
+      after_initialize :add_class_event_handlers
+      
+      inheritable_attr :responds_to_event_options
+      self.responds_to_event_options = []
+    end
+    
+    
+    attr_writer :page_updates
+    
+    def page_updates
+      @page_updates ||= []
+    end
+    
+    
+    module ClassMethods
+      # Instructs the widget to look out for +type+ events. If an appropriate event starts from or passes the widget, 
+      # the defined trigger state is executed.
+      #
+      #   class MouseWidget < Apotomo::Widget
+      #     responds_to_event :squeak
+      #
+      #     def squeak(evt)
+      #       update
+      #     end
+      #
+      # Calls #squeak when a <tt>:squeak</tt> event is encountered.
+      # 
+      # == Options
+      # Any option except the event +type+ is optional.
+      #
+      # [<tt>:with => state</tt>] 
+      #   executes +state+, defaults to +type+.
+      #     responds_to_event :squeak, :with => :chirp
+      #   will invoke the +#chirp+ state method.
+      # [<tt>:on => id</tt>] 
+      #   execute the trigger state on another widget.
+      #     responds_to_event :squeak, :on => :cat
+      #   will invoke the +#squeak+ state on the +:cat+ widget.
+      # [<tt>:from => id</tt>] 
+      #   executes the state <em>only</em> if the event origins from +id+.
+      #     responds_to_event :squeak, :from => :kid
+      #   will invoke the +#squeak+ state if +:kid+ triggered <em>and</em> if +:kid+ is a decendent of the current widget.
+      # [<tt>:passing => id</tt>] 
+      #   attaches the observer to another widget. Useful if you want to catch bubbling events in +root+.
+      #     responds_to_event :squeak, :passing => :root
+      #   will invoke the state on the current widget if the event passes +:root+ (which is highly probable).
+      #
+      # == Inheritance
+      # Note that the observers are inherited. This allows deriving a widget class without having to redefine the
+      # responds_to_event blocks.
+      def responds_to_event(*options)
+        # DISCUSS: this is a Hooks.declarative_attr candidate, too.
+        return set_global_event_handler(*options) if options.dup.extract_options![:passing]
+        
+        responds_to_event_options << options
+      end
+      
+    private
+      # Adds an event handler to a non-local widget. Called in #responds_to_event when the 
+      # :passing option is set.
+      #
+      # This usually leads to something like 
+      #   root.respond_to_event :click, :on => 'jerry'
+      def set_global_event_handler(type, options)
+        after_add do
+          opts = options.reverse_merge(:on => widget_id)
+          root.find_widget(opts.delete(:passing)).respond_to_event(type, opts)
+        end
+      end
+    end
+    
+    # Same as #responds_to_event but executed on the widget instance, only.
+    def respond_to_event(type, options={})
+      options = options.reverse_merge(:once => true,
+                                      :with => type,
+                                      :on   => self.name)
+      
+      handler = InvokeEventHandler.new(:widget_id => options[:on], :state => options[:with])
+      
+      return if options[:once] and event_table.all_handlers_for(type, options[:from]).include?(handler)
+      
+      on(type, :call => handler, :from => options[:from])
+    end
+    
+    # Fire an event of +type+ and let it bubble up. You may add arbitrary payload data to the event.
+    #
+    # Example:
+    #
+    #   trigger(:dropped, :area => 59)
+    #
+    # which can be queried in a triggered state.
+    #
+    #   def on_drop(event)
+    #     if event[:area] == 59 
+    def trigger(*args)
+      fire(*args)
+    end
+    
+    # Get all handlers from self for the passed event (overriding Onfire#local_event_handlers).
+    def handlers_for_event(event)
+      event_table.all_handlers_for(event.type, event.source.name) # we key with widget_id.
+    end
+    
+  protected
+    def event_for(*args)  # defined in Onfire: we want Apotomo::Event.
+      Event.new(*args)
+    end
+    
+    # Actually executes the #responds_to_event calls from the class on the instance.
+    def add_class_event_handlers(*)
+      self.class.responds_to_event_options.each { |options| respond_to_event(*options) }
+    end
+  end
+end

data/lib/apotomo/widget/javascript_methods.rb

@@ -5,28 +5,32 @@ module Apotomo
       Apotomo.js_generator.escape(script)
     end
     
-    # Wraps the rendered content in a replace statement targeted at your +Apotomo.js_framework+ setting.
-    # Use +:selector+ to change the selector.
+    # Wraps the rendered content in a replace statement according to your +Apotomo.js_framework+ setting.
+    # Received the same options as #render plus an optional +selector+ to change the selector.
     #
-    # Example:
+    # Example (with <tt>Apotomo.js_framework = :jquery</tt>):
     #
-    # Assuming you set 
-    #   Apotomo.js_framework = :jquery
+    #   def hungry
+    #     replace 
     #
-    # and call replace in a state
+    # will render the current state's view and wrap it like
     #
-    #   replace :view => :squeak, :selector => "div#mouse"
-    #   #=> "$(\"div#mouse\").replaceWith(\"<div id=\\\"mum\\\">squeak!<\\/div>\")"
+    #   "$(\"#mouse\").replaceWith(\"<div id=\\\"mouse\\\">hungry!<\\/div>\")"
+    #
+    # You may pass a selector and pass options to render here, as well.
+    #
+    #     replace "#jerry h1", :view => :squeak 
+    #     #=> "$(\"#jerry h1\").replaceWith(\"<div id=\\\"mouse\\\">squeak!<\\/div>\")"
     def replace(*args)
       wrap_in_javascript_for(:replace, *args)
     end
     
-    # Same as replace except that the content is wrapped in an update statement.
+    # Same as #replace except that the content is wrapped in an update statement.
     #
     # Example for +:jquery+:
     #
-    #   update :view => :squeak
-    #   #=> "$(\"mum\").html(\"<div id=\\\"mum\\\">squeak!<\\/div>\")"
+    #   update :view => :peek
+    #   #=> "$(\"#mouse\").html(\"looking...")"
     def update(*args)
       wrap_in_javascript_for(:update, *args)
     end

data/lib/apotomo/widget.rb

@@ -2,13 +2,14 @@ require 'cells'
 require 'onfire'
 require 'hooks'
 
-require 'apotomo/tree_node'
+
 require 'apotomo/event'
-require 'apotomo/event_methods'
 require 'apotomo/widget_shortcuts'
 require 'apotomo/rails/view_helper'
 require 'apotomo/rails/controller_methods'  # FIXME.
 
+require 'apotomo/widget/tree_node'
+require 'apotomo/widget/event_methods'
 require 'apotomo/widget/javascript_methods'
 
 
@@ -108,22 +109,21 @@ module Apotomo
       render_state(state)
     end
     
-    # Render the view for the current state. Usually called at the end of a state method.
+    # Renders and returns a view for the current state. That's why it is usually called at the end of 
+    # a state method.
     #
     # ==== Options
-    # * <tt>:view</tt> - Specifies the name of the view file to render. Defaults to the current state name.
-    # * <tt>:template_format</tt> - Allows using a format different to <tt>:html</tt>.
-    # * <tt>:layout</tt> - If set to a valid filename inside your cell's view_paths, the current state view will be rendered inside the layout (as known from controller actions). Layouts should reside in <tt>app/cells/layouts</tt>.
-    # * see Cell::Base#render for additional options
+    # * <tt>:view</tt> - Renders +view+. Defaults to the current state name.
+    # * <tt>:state</tt> - Invokes the +state+ method and returns whatever the state returns.
+    # * See http://rdoc.info/gems/cells/3.5.4/Cell/Rails#render-instance_method
     #
     # Example:
-    #  class MouseWidget < Apotomo::StatefulWidget
+    #  class MouseWidget < Apotomo::Widget
     #    def eat
-    #      # ... do something
     #      render 
     #    end
     #
-    # will just render the view <tt>eat.haml</tt>.
+    # render the view <tt>eat.haml</tt>.
     #
     #  render :js => "alert('SQUEAK!');"
     #
@@ -141,7 +141,7 @@ module Apotomo
     end
     
     
-    # Returns the widget named <tt>widget_id</tt> as long as it is below self or self itself.
+    # Returns the widget named +widget_id+ if it's a descendent or self.
     def find_widget(widget_id)
       find {|node| node.name.to_s == widget_id.to_s}
     end

data/lib/generators/apotomo/widget_generator.rb

@@ -2,17 +2,27 @@ require 'generators/cells/base'
 
 module Apotomo
   module Generators
-    class WidgetGenerator < ::Cells::Generators::Base
-      source_root File.expand_path(File.join(File.dirname(__FILE__), '../templates'))
-      
-      def create_cell_file
-        template 'widget.rb', File.join('app/widgets', class_path, "#{file_name}_widget.rb")
+    module BasePathMethods
+    private
+      def base_path
+        File.join('app/widgets', class_path, file_name)
       end
+    end
+    
+    class WidgetGenerator < ::Cells::Generators::Base
+      include BasePathMethods
       
-      check_class_collision :suffix => "Widget"
+      source_root File.expand_path('../../templates', __FILE__)
       
       hook_for(:template_engine)
       hook_for(:test_framework)  # TODO: implement rspec-apotomo.
+      
+      check_class_collision :suffix => "Widget"
+      
+      
+      def create_cell_file
+        template 'widget.rb', "#{base_path}_widget.rb"
+      end
     end
   end
 end

data/lib/generators/erb/widget_generator.rb

@@ -1,17 +1,11 @@
-require 'generators/cells/base'
+require 'generators/erb/cell_generator'
+require 'generators/apotomo/widget_generator'
 
 module Erb
   module Generators
-    class WidgetGenerator < ::Cells::Generators::Base
+    class WidgetGenerator < CellGenerator
+      include ::Apotomo::Generators::BasePathMethods
       source_root File.expand_path('../../templates', __FILE__)
-
-      def create_views
-        for state in actions do
-          @state = state
-          @path = File.join('app/widgets', file_name, "#{state}.html.erb")
-          template "view.erb", @path
-        end
-      end
     end
   end
 end

data/lib/generators/haml/widget_generator.rb

@@ -1,20 +1,11 @@
-require 'generators/cells/base'
+require 'generators/haml/cell_generator'
+require 'generators/apotomo/widget_generator'
 
 module Haml
   module Generators
-    class WidgetGenerator < ::Cells::Generators::Base
+    class WidgetGenerator < CellGenerator
+      include ::Apotomo::Generators::BasePathMethods
       source_root File.expand_path('../../templates', __FILE__)
-
-      def create_views
-        for state in actions do
-          @state  = state
-          @path   = File.join('app/widgets', file_name, "#{state}.html.haml")
-
-          template "view.haml", @path
-        end
-      end
     end
   end
 end
-
-

data/lib/generators/slim/widget_generator.rb

@@ -0,0 +1,11 @@
+require 'generators/slim/cell_generator'
+require 'generators/apotomo/widget_generator'
+
+module Slim
+  module Generators
+    class WidgetGenerator < CellGenerator
+      include ::Apotomo::Generators::BasePathMethods
+      source_root File.expand_path('../../templates', __FILE__)
+    end
+  end
+end

data/lib/generators/templates/view.slim

@@ -0,0 +1,4 @@
+h1
+  <%= class_name %>Widget#<%= @state %>
+p
+  Find me in <%= @path %>

data/test/rails/widget_generator_test.rb

@@ -34,6 +34,18 @@ class WidgetGeneratorTest < Rails::Generators::TestCase
         assert_file "app/widgets/gerbil/squeak.html.haml", %r(app/widgets/gerbil/squeak\.html\.haml)
         assert_file "test/widgets/gerbil_widget_test.rb"
       end
+
+      should "create slim assets with -e slim" do
+        run_generator %w(Gerbil squeak snuggle -e slim -t test_unit)
+        
+        assert_file "app/widgets/gerbil_widget.rb", /class GerbilWidget < Apotomo::Widget/
+        assert_file "app/widgets/gerbil_widget.rb", /def snuggle/
+        assert_file "app/widgets/gerbil_widget.rb", /def squeak/
+        assert_file "app/widgets/gerbil/snuggle.html.slim", %r(app/widgets/gerbil/snuggle\.html\.slim)
+        assert_file "app/widgets/gerbil/snuggle.html.slim", %r(p)
+        assert_file "app/widgets/gerbil/squeak.html.slim", %r(app/widgets/gerbil/squeak\.html\.slim)
+        assert_file "test/widgets/gerbil_widget_test.rb"
+      end
     end
   end
 end

data/test/unit/event_methods_test.rb

@@ -3,6 +3,11 @@ require 'test_helper'
 class EventMethodsTest < Test::Unit::TestCase
   include Apotomo::TestCaseMethods::TestController
   
+  def handler(id, state)
+    Apotomo::InvokeEventHandler.new(:widget_id => id, :state => state)
+  end
+  
+  
   context "#respond_to_event and #fire" do
     setup do
       mum_and_kid!
@@ -70,28 +75,56 @@ class EventMethodsTest < Test::Unit::TestCase
       assert_equal [{:volume => 9}], @mum.list
     end
     
+    
+    context "#responds_to_event with :passing" do
+      setup do
+        class AdolescentMouse < MouseWidget
+          responds_to_event :squeak, :passing => :root
+        end
+        
+        @root = mouse_mock(:root)
+      end
+      
+      should "add handlers to root when called with :passing" do
+        @root << AdolescentMouse.new(parent_controller, 'jerry')
+        
+        assert_equal [handler('jerry', :squeak)], @root.event_table.all_handlers_for(:squeak, 'jerry')
+      end
+      
+      should "inherit :passing handlers" do
+        @root << Class.new(AdolescentMouse).new(parent_controller, 'jerry')
+        
+        assert_equal [handler('jerry', :squeak)], @root.event_table.all_handlers_for(:squeak, 'jerry')
+      end
+      
+    end
+    
     context "#responds_to_event in class context" do
       setup do
         class AdultMouse < MouseWidget
           responds_to_event :peep, :with => :answer_squeak
         end
         class BabyMouse < AdultMouse
+          responds_to_event :peep
           responds_to_event :footsteps, :with => :squeak
         end
+        
+        @mum = AdultMouse.new(parent_controller, 'mum')
       end
       
       should "add the handlers at creation time" do
-        assert_equal [Apotomo::InvokeEventHandler.new(:widget_id => 'mum', :state => :answer_squeak)], AdultMouse.new(parent_controller, 'mum', :show).event_table.all_handlers_for(:peep, 'mum')
+        assert_equal [handler('mum', :answer_squeak)], @mum.event_table.all_handlers_for(:peep, 'mum')
       end
       
-      should "not inherit handlers for now" do
-        assert_equal [], BabyMouse.new(parent_controller, 'kid', :show).event_table.all_handlers_for(:peep, 'kid')
+      should "inherit handlers" do
+        @peep_handlers = BabyMouse.new(parent_controller, 'kid', :show).event_table.all_handlers_for(:peep, 'kid')
+        assert_equal [handler('kid', :answer_squeak), handler('kid', :peep)], @peep_handlers
       end
       
-      should "not add the same handler to each instance" do
-        assert_equal [Apotomo::InvokeEventHandler.new(:widget_id => 'mum', :state => :answer_squeak)], AdultMouse.new(parent_controller, 'mum', :show).event_table.all_handlers_for(:peep, 'mum')
+      should "not share responds_to_event options between different instances" do
+        assert_equal [handler('mum', :answer_squeak)], @mum.event_table.all_handlers_for(:peep, 'mum')
         
-        assert_equal [Apotomo::InvokeEventHandler.new(:widget_id => 'dad', :state => :answer_squeak)], AdultMouse.new(parent_controller, 'dad', :show).event_table.all_handlers_for(:peep, 'dad')
+        assert_equal [handler('dad', :answer_squeak)], AdultMouse.new(parent_controller, 'dad', :show).event_table.all_handlers_for(:peep, 'dad')
       end
     end
     

data/test/unit/event_test.rb

@@ -1,12 +1,10 @@
 require 'test_helper'
  
 class EventTest < Test::Unit::TestCase
+  include Apotomo::TestCaseMethods::TestController
+  
   context "An Event" do
-    should "require type and respond to #type" do
-      assert_equal :footsteps, Apotomo::Event.new(:footsteps).type
-    end
-    
-    should "require source and respond to #source" do
+    should "respond to #type and #source" do
       @event = Apotomo::Event.new(:footsteps, 'mum')
       assert_equal :footsteps,  @event.type
       assert_equal 'mum',       @event.source
@@ -22,14 +20,9 @@ class EventTest < Test::Unit::TestCase
       assert_equal :loud, @event[:volume]
     end
     
-    should "complain when serialized" do
-      assert_raises RuntimeError do
-        Marshal.dump(Apotomo::Event.new(:footsteps, 'mum'))
-      end
-    end
-    
-    should "respond to #stopped?" do
-      assert_not Apotomo::Event.new(:footsteps, 'mum').stopped?
+    should "respond to #to_s" do
+      @event = Apotomo::Event.new(:footsteps, mouse_mock('mum'))
+      assert_equal "<Event :footsteps source=mum>", @event.to_s
     end
   end
 end

data/test/unit/widget_test.rb

@@ -50,7 +50,7 @@ class WidgetTest < ActiveSupport::TestCase
       assert_equal ['mum', 'kid'], @root.children.collect { |w| w.name }
     end
     
-    should "inherit callbacks for now" do
+    should "inherit callbacks" do
       @berry = Class.new(@mum.class).new(@controller, 'berry', :squeak)
       @root << @berry
       
@@ -93,10 +93,26 @@ class WidgetTest < ActiveSupport::TestCase
       end
     end
     
-    should "respond to #find_widget" do
-      mum_and_kid!
-      assert_not @mum.find_widget('pet')
-      assert_equal @kid, @mum.find_widget('kid')
+    context "#find_widget" do
+      setup do
+        mum_and_kid!
+      end
+      
+      should "find itself" do
+        assert_equal @mum, @mum.find_widget('mum')
+      end
+      
+      should "return nil for not-existant widgets" do
+        assert_nil @mum.find_widget('pet')
+      end
+      
+      should "find children" do
+        assert_equal @kid, @mum.find_widget('kid')
+      end
+      
+      should "find treat 'id' and :id the same" do
+        assert_equal @mum.find_widget(:kid), @mum.find_widget('kid')
+      end
     end
     
     should "respond to the WidgetShortcuts methods, like #widget" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 1
-  - 0
-  version: 1.1.0
+  - 1
+  version: 1.1.1
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-01 00:00:00 +01:00
+date: 2011-03-25 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,8 +42,8 @@ dependencies:
         segments: 
         - 3
         - 5
-        - 4
-        version: 3.5.4
+        - 6
+        version: 3.5.6
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -56,9 +56,9 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 1
         - 2
-        version: 0.1.2
+        - 0
+        version: 0.2.0
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -89,6 +89,19 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: slim
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
 description: Web component framework for Rails providing widgets that trigger events and know when and how to update themselves with AJAX.
 email: 
 - apotonick@gmail.com
@@ -109,9 +122,9 @@ files:
 - config/routes.rb
 - lib/apotomo.rb
 - lib/apotomo/apotomo.rake
+- lib/apotomo/debugging.rb
 - lib/apotomo/event.rb
 - lib/apotomo/event_handler.rb
-- lib/apotomo/event_methods.rb
 - lib/apotomo/invoke_event_handler.rb
 - lib/apotomo/javascript_generator.rb
 - lib/apotomo/proc_event_handler.rb
@@ -120,17 +133,20 @@ files:
 - lib/apotomo/railtie.rb
 - lib/apotomo/request_processor.rb
 - lib/apotomo/test_case.rb
-- lib/apotomo/tree_node.rb
 - lib/apotomo/version.rb
 - lib/apotomo/widget.rb
+- lib/apotomo/widget/event_methods.rb
 - lib/apotomo/widget/javascript_methods.rb
+- lib/apotomo/widget/tree_node.rb
 - lib/apotomo/widget_shortcuts.rb
 - lib/generators/apotomo/USAGE
 - lib/generators/apotomo/widget_generator.rb
 - lib/generators/erb/widget_generator.rb
 - lib/generators/haml/widget_generator.rb
+- lib/generators/slim/widget_generator.rb
 - lib/generators/templates/view.erb
 - lib/generators/templates/view.haml
+- lib/generators/templates/view.slim
 - lib/generators/templates/widget.rb
 - lib/generators/templates/widget_test.rb
 - lib/generators/test_unit/widget_generator.rb

data/lib/apotomo/event_methods.rb

@@ -1,95 +0,0 @@
-require 'apotomo/invoke_event_handler'
-
-module Apotomo
-  # Introduces event-processing functions into the StatefulWidget.
-  module EventMethods
-    extend ActiveSupport::Concern
-    
-    included do
-      after_initialize :add_class_event_handlers
-    end
-    
-    attr_writer :page_updates
-    
-    def page_updates
-      @page_updates ||= []
-    end
-    
-    def add_class_event_handlers(*)
-      self.class.responds_to_event_options.each { |options| respond_to_event(*options) }
-    end
-    
-    module ClassMethods
-      def responds_to_event(*options)
-        responds_to_event_options << options
-      end
-      alias_method :respond_to_event, :responds_to_event
-      
-      def responds_to_event_options
-        @responds_to_event_options ||= []
-      end
-    end
-    # Instructs the widget to look out for <tt>type</tt> Events that are passing by while bubbling.
-    # If an appropriate event is encountered the widget will send the targeted widget (or itself) to another
-    # state, which implies an update of the invoked widget.
-    #
-    # You may configure the event handler with the following <tt>options</tt>:
-    #  :with  => (optional) the state to invoke on the target widget, defaults to +type+.
-    #  :on    => (optional) the targeted widget's id, defaults to <tt>self.name</tt>
-    #  :from  => (optional) the source id of the widget that triggered the event, defaults to any widget
-    #
-    # Example:
-    #   
-    #   trap = widget(:trap, :charged, 'mouse_trap')
-    #   trap.respond_to_event :mouseOver, :with => :catch_mouse
-    #
-    # This would instruct +trap+ to catch a <tt>:mouseOver</tt> event from any widget (including itself) and
-    # to invoke the state <tt>:catch_mouse</tt> on itself as trigger.
-    #
-    #   
-    #   hunter = widget(:form, :hunt_for_mice, 'my_form')
-    #     hunter << widget(:input_field, :smell_like_cheese,  'mouse_trap')
-    #     hunter << widget(:text_area,   :stick_like_honey,   'bear_trap')
-    #   hunter.respond_to_event :captured, :from => 'mouse_trap', :with => :refill_cheese, :on => 'mouse_trap'
-    #
-    # As both the bear- and the mouse trap can trigger a <tt>:captured</tt> event the later <tt>respond_to_event</tt>
-    # would invoke <tt>:refill_cheese</tt> on the <tt>mouse_trap</tt> widget as soon as this and only this widget fired.
-    # It is important to understand the <tt>:from</tt> parameter as it filters the event source - it wouldn't make
-    # sense to refill the mouse trap if the bear trap snapped, would it? 
-    def respond_to_event(type, options={})
-      options = options.reverse_merge(:once => true,
-                                      :with => type,
-                                      :on   => self.name)
-      
-      handler = InvokeEventHandler.new(:widget_id => options[:on], :state => options[:with])
-      
-      return if options[:once] and event_table.all_handlers_for(type, options[:from]).include?(handler)
-      
-      on(type, :do => handler, :from => options[:from])
-    end
-    
-    # Fire an event of +type+ and let it bubble up. You may add arbitrary payload data to the event.
-    #
-    # Example:
-    #
-    #   trigger(:dropped, :area => 59)
-    #
-    # which can be queried in a triggered state.
-    #
-    #   def on_drop(event)
-    #     if event[:area] == 59 
-    def trigger(*args)
-      fire(*args)
-    end
-    
-  protected
-    # Get all handlers from self for the passed event (overriding Onfire#local_event_handlers).
-    def local_event_handlers(event)
-      event_table.all_handlers_for(event.type, event.source.name) # we key with widget_id.
-    end
-    
-    def event_for(*args)  # defined in Onfire: we want Apotomo::Event.
-      Event.new(*args)
-    end
-  end
-end