apotomo 1.1.4 → 1.2.0

data/CHANGES.textile

@@ -1,3 +1,14 @@
+h2. 1.2.0
+
+h3. Changes
+  * The @Widget.new@ constructor now expects the parent widget as first argument (except for the root widget, which still gets the damned ActionController instance). Nobody needed orphaned widgets so far so we decided to make it simpler. This makes the @#<<@ method a DSL-method, only.
+  * You can now access the root widget instance (or any other parent widget) in any subsequent @has_widgets@ block. This fixes "a famous issue":https://github.com/apotonick/apotomo/issues/34 and makes the @:passing@ option work as expected at every tree level.
+  * The @#widget@ shortcut method no longer returns a valid widget instance but a DSL-specific thing. Use the real constructor form if you need it right away (@MouseWidget.new(parent, :kid)@) or access the instance afterwards (@root[:kid]@).
+  * Removed the @after_add@ hook. Now that adding happens in the constructor, hook into @after_initialize@.
+  * Removed @#param@ in favor of @#options@.
+  * Removed @#emit@ in favor of @#render@.
+  * Removed @#remove_all!@ and @#remove_from_parent!@. Did you ever use these?
+  
 h2. 1.1.4
 
 h3. Changes

data/Rakefile

@@ -8,6 +8,6 @@ task :default => :test
 
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
-  test.test_files = FileList['test/unit/*_test.rb', 'test/rails/*_test.rb']# - ['test/rails/capture_test.rb']
+  test.test_files = FileList['test/*_test.rb', 'test/rails/*_test.rb']
   test.verbose = true
 end

data/apotomo.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   
   s.add_dependency "cells",   ">= 3.6.7"
   s.add_dependency "onfire",  "~> 0.2.0"
-  s.add_dependency "hooks",   "~> 0.1.3"
+  s.add_dependency "hooks",   "~> 0.2.0"
 
   s.add_development_dependency "shoulda"
   s.add_development_dependency "rake"

data/lib/apotomo/rails/controller_methods.rb

@@ -48,7 +48,7 @@ module Apotomo
         return @apotomo_request_processor if @apotomo_request_processor
         
         # happens once per request:
-        options = { :js_framework   => Apotomo.js_framework || :prototype } # FIXME: remove :prototype
+        options = {:js_framework   => Apotomo.js_framework}
         
         @apotomo_request_processor = Apotomo::RequestProcessor.new(self, options, self.class.has_widgets_blocks)
       end
@@ -84,13 +84,6 @@ module Apotomo
       end
       
     protected
-      
-      # TODO: remove me! only needed in widget_shortcuts.
-      def parent_controller
-        self
-      end
-      
-      
       # Renders the page updates through an iframe. Copied from responds_to_parent,
       # see http://github.com/markcatley/responds_to_parent .
       def render_iframe_updates(page_updates)

data/lib/apotomo/request_processor.rb

@@ -12,7 +12,7 @@ module Apotomo
     
     
     def initialize(controller, options={}, has_widgets_blocks=[])
-      @root = Widget.new(controller, 'root')
+      @root = Widget.new(controller, :root)
       
       attach_stateless_blocks_for(has_widgets_blocks, @root, controller)
       

data/lib/apotomo/version.rb

@@ -1,3 +1,3 @@
 module Apotomo
-  VERSION = '1.1.4'
+  VERSION = '1.2.0'
 end

data/lib/apotomo/widget.rb

@@ -39,7 +39,6 @@ module Apotomo
     
     DEFAULT_VIEW_PATHS = [
       File.join('app', 'widgets'),
-      File.join('app', 'widgets', 'layouts')
     ]
     
     include Hooks
@@ -50,14 +49,11 @@ module Apotomo
     # Example:
     #
     #   class MouseWidget < Apotomo::Widget
-    #     after_initialize :setup_cheese
-    #     
-    #     # we need @cheese in every state:
-    #     def setup_cheese(*)
+    #     after_initialize do
     #       @cheese = Cheese.find options[:cheese_id]
+    #     end
     define_hook :after_initialize
     define_hook :has_widgets
-    define_hook :after_add
     
     attr_writer :visible
     
@@ -73,32 +69,30 @@ module Apotomo
     helper Apotomo::Rails::ActionViewMethods
     
     abstract!
-    
     undef :display  # We don't want #display to be listed in #internal_methods.
     
     alias_method :widget_id, :name
     
-    
-    # Runs callbacks for +name+ hook in instance context.  
-    def run_widget_hook(name, *args)
-      self.class.callbacks_for_hook(name).each { |blk| instance_exec(*args, &blk) }
-    end
-    
-    def add_has_widgets_blocks(*)
-      run_widget_hook(:has_widgets, self)
+    after_initialize do
+      run_hook :has_widgets, self
     end
-    after_initialize :add_has_widgets_blocks
     
     
-    def initialize(parent_controller, id, options={})
-      super(parent_controller, options)  # do that as long as cells do need a parent_controller.
-      
+    def initialize(parent, id, options={})
+      super(parent, options)  # TODO: do that as long as cells do need a parent_controller. remember to remove options for cells 3.7.
       @name         = id
       @visible      = true
       
+      setup_tree_node(parent)
+      
       run_hook :after_initialize, self
     end
     
+    def parent_controller
+      # i hope we'll get rid of any parent_controller dependency, soon.
+      root? ? @parent_controller : root.parent_controller
+    end
+    
     def visible?
       @visible
     end
@@ -132,15 +126,6 @@ module Apotomo
       super
     end
     
-    alias_method :emit, :render
-    
-    def param(name)
-      msg = "Deprecated. Use #options for widget constructor options or #params for request data."
-      ActiveSupport::Deprecation.warn(msg)
-      raise msg
-    end
-    
-    
     # 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}

data/lib/apotomo/widget/event_methods.rb

@@ -6,7 +6,19 @@ module Apotomo
     extend ActiveSupport::Concern
     
     included do
-      after_initialize :add_class_event_handlers
+      after_initialize do
+        self.class.responds_to_event_options.each do |args|
+          type, options = args[0], args[1] || {}
+          target = self
+          
+          if target_id = options[:passing]
+             target = root.find_widget(target_id)
+             options[:on] ||= widget_id
+          end
+          
+          target.respond_to_event(type, options)
+        end
+      end
       
       inheritable_attr :responds_to_event_options
       self.responds_to_event_options = []
@@ -57,34 +69,18 @@ module Apotomo
       # 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={})
+      # DISCUSS: do we need the :once option? how could we avoid re-adding?
       options = options.reverse_merge(:once => true,
                                       :with => type,
-                                      :on   => self.name)
+                                      :on   => widget_id)
       
       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])
@@ -113,10 +109,5 @@ module Apotomo
     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/tree_node.rb

@@ -1,22 +1,17 @@
-# stolen from ... ? couldn't find the original lib on the net.
-### TODO: insert copyright notice!
-
 module Apotomo
   module TreeNode
     include Enumerable
+    include Apotomo::WidgetShortcuts::DSL
 
     attr_reader :name, :childrenHash
     attr_accessor :parent
   
-    def self.included(base)
-      base.after_initialize :initialize_tree_node
-    end
-  
-    def initialize_tree_node(*)
-      root!
-
+    def setup_tree_node(parent)
+      @parent       = nil
       @childrenHash = {}
-      @children = []
+      @children     = []
+      
+      parent.add_widget(self) if parent.kind_of? Widget # TODO: as long as cells needs parent_controller.
     end
 
     # Print the string representation of this node.
@@ -25,26 +20,13 @@ module Apotomo
         " Children: #{children.length}" + " Total Nodes: #{size}"
     end
 
-    # Convenience synonym for Tree#add method.
-    # This method allows a convenient method to add
-    # children hierarchies in the tree.
-    # E.g. root << child << grand_child
-    def <<(child)
-      add(child)
-    end
-
-    # Adds the specified child node to the receiver node.
-    # The child node's parent is set to be the receiver.
-    # The child is added as the last child in the current
-    # list of children for the receiver node.
-    def add(child)
+    def add_widget(child)  # TODO: rename #add, make private
       raise "Child already added" if @childrenHash.has_key?(child.name)
-
-      @childrenHash[child.name]  = child
+      
+      @childrenHash[child.widget_id] = child
       @children << child
       child.parent = self
     
-      child.run_widget_hook(:after_add, child, self)
       child
     end
 
@@ -59,23 +41,6 @@ module Apotomo
       child
     end
 
-    # Removes this node from its parent. If this is the root node,
-    # then does nothing.
-    def remove_from_parent!
-      @parent.remove!(self) unless root?
-    end
-
-    # Removes all children from the receiver node.
-    def remove_all!
-      for child in @children
-        child.root!
-      end
-      @childrenHash.clear
-      @children.clear
-      self
-    end
-  
-  
     # Private method which sets this node as a root node.
     def root!
       @parent = nil
@@ -127,7 +92,6 @@ module Apotomo
 
     # Pretty prints the tree starting with the receiver node.
     def printTree(tab = 0)
-      puts((' ' * tab) + self.to_s)
       children {|child| child.printTree(tab + 4)}
     end
 
@@ -174,4 +138,4 @@ module Apotomo
       path.reverse.join("/")
     end
   end
-end
+end

data/lib/apotomo/widget_shortcuts.rb

@@ -1,13 +1,15 @@
 module Apotomo
-  # Shortcut methods for creating widget trees.
+  # Create widget trees using the #widget DSL.
   module WidgetShortcuts
     # Shortcut for creating an instance of <tt>class_name+"_widget"</tt> named +id+. Yields self.
+    # Note that this creates a proxy object, only. The actual widget is built not until you added 
+    # it, e.g. using #<<.
     #
     # Example:
     # 
-    #   widget(:comments)
+    #   root << widget(:comments)
     # 
-    # will create a +CommentsWidget+ with id :comments.
+    # will create a +CommentsWidget+ with id :comments attached to +root+.
     #
     #   widget(:comments, 'post-comments', :user => current_user)
     #
@@ -16,18 +18,45 @@ module Apotomo
     # You can also use namespaces.
     #
     #   widget('jquery/tabs', 'panel')
-    def widget(prefix, *args)
-      options = args.extract_options!
-      id      = args.shift || prefix
-      
-      constant_for(prefix).new(parent_controller, id, options).tap do |object|
-        yield object if block_given?  
-      end
+    #
+    # Add a block if you need to grab the created widget right away.
+    #
+    #   root << widget(:comments) do |comments|
+    #     comments.markdown!
+    #   end
+    #
+    # Using #widget is just a shortcut, you can always use the constructor as well.
+    #
+    #   CommentsWidget.new(root, :comments) 
+    def widget(*args, &block)
+      FactoryProxy.new(*args, &block)
     end
     
+    class FactoryProxy
+      def initialize(prefix, *args, &block)
+        options = args.extract_options!
+        id      = args.shift || prefix
+        
+        @prefix, @id, @options, @block = prefix, id, options, block
+      end
+      
+      def build(parent)
+        widget = constant_for(@prefix).new(parent, @id, @options)
+        @block.call(widget) if @block
+        widget
+      end
+      
     private
       def constant_for(class_name)  # TODO: use Cell.class_from_cell_name. 
         "#{class_name}_widget".classify.constantize
       end
+    end
+    
+    # Mixed into Widget.      
+    module DSL
+      def <<(child)
+        child.build(self)
+      end
+    end
   end
 end

data/test/{unit/event_handler_test.rb → event_handler_test.rb}

@@ -6,18 +6,18 @@ class EventHandlerTest < Test::Unit::TestCase
   
   context "an abstract EventHandler" do
     should "push nil to root's ordered page_updates when #call'ed" do
-      @mum = mouse_mock('mum')
-        @mum << @kid = mouse_mock('kid')
+      @mum = mouse
+        @mum << mouse_mock(:kid)
       
       assert_equal 0, @mum.page_updates.size
       
-      [@mum, @kid, @mum].each do |source|
+      [@mum, @mum[:kid], @mum].each do |source|
         Apotomo::EventHandler.new.call(Apotomo::Event.new(:squeak, source))
       end
       
       # order matters:
       assert_equal 3, @mum.page_updates.size
-      assert_equal 0, @kid.page_updates.size
+      assert_equal 0, @mum[:kid].page_updates.size
       assert_equal(nil, @mum.page_updates[0])
       assert_equal(nil, @mum.page_updates[1])
       assert_equal(nil, @mum.page_updates[2])

data/test/{unit/event_methods_test.rb → event_methods_test.rb}

@@ -18,9 +18,9 @@ class EventMethodsTest < Test::Unit::TestCase
       assert_equal ['be alerted', 'answer squeak'], @mum.list
     end
     
-    should "make @mum just squeak back when @jerry squeaks" do
-      @mum << @jerry = mouse_mock('jerry')
-      @jerry.fire :squeak
+    should "make @mum just squeak back when jerry squeaks" do
+      @mum << mouse_mock(:jerry)
+      @mum[:jerry].fire :squeak
       assert_equal ['answer squeak'], @mum.list
     end
     
@@ -82,17 +82,17 @@ class EventMethodsTest < Test::Unit::TestCase
           responds_to_event :squeak, :passing => :root
         end
         
-        @root = mouse_mock(:root)
+        @root = mouse(:root)
       end
       
       should "add handlers to root when called with :passing" do
-        @root << AdolescentMouse.new(parent_controller, 'jerry')
+        AdolescentMouse.new(@root, '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')
+        Class.new(AdolescentMouse).new(@root, 'jerry')
         
         assert_equal [handler('jerry', :squeak)], @root.event_table.all_handlers_for(:squeak, 'jerry')
       end
@@ -100,15 +100,15 @@ class EventMethodsTest < Test::Unit::TestCase
     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
+      class AdultMouse < Apotomo::Widget
+        responds_to_event :peep, :with => :answer_squeak
+      end
+      class BabyMouse < AdultMouse
+        responds_to_event :peep
+        responds_to_event :footsteps, :with => :squeak
+      end
         
+      setup do
         @mum = AdultMouse.new(parent_controller, 'mum')
       end
       
@@ -117,8 +117,8 @@ class EventMethodsTest < Test::Unit::TestCase
       end
       
       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
+        assert_equal [[:peep, {:with=>:answer_squeak}]], AdultMouse.responds_to_event_options
+        assert_equal [[:peep, {:with=>:answer_squeak}], [:peep], [:footsteps, {:with=>:squeak}]], BabyMouse.responds_to_event_options
       end
       
       should "not share responds_to_event options between different instances" do

data/test/{unit/event_test.rb → event_test.rb}

@@ -21,7 +21,7 @@ class EventTest < Test::Unit::TestCase
     end
     
     should "respond to #to_s" do
-      @event = Apotomo::Event.new(:footsteps, mouse_mock('mum'))
+      @event = Apotomo::Event.new(:footsteps, mouse('mum'))
       assert_equal "<Event :footsteps source=mum>", @event.to_s
     end
   end

data/test/{unit/onfire_integration_test.rb → onfire_integration_test.rb}

@@ -5,8 +5,9 @@ class OnfireIntegrationTest < Test::Unit::TestCase
   
   context "including Onfire into the StatefulWidget it" do
     setup do
-      @mum = mouse_mock('mum')
-      @mum << @kid = mouse_mock('kid')
+      @mum = mouse('mum')
+      @mum << mouse_mock(:kid)
+      @kid = @mum[:kid]
     end
     
     should "respond to #root" do

data/test/rails/controller_methods_test.rb

@@ -22,10 +22,6 @@ class ControllerMethodsTest < ActionController::TestCase
       end
     end
     
-    should "respond to parent_controller" do
-      assert_equal @controller, @controller.send(:parent_controller)
-    end
-    
     context "invoking #has_widgets" do
       setup do
         @controller.class.has_widgets do |root|

data/test/rails/rails_integration_test.rb

@@ -3,63 +3,90 @@ require 'test_helper'
 class RailsIntegrationTest < ActionController::TestCase
   include Apotomo::TestCaseMethods::TestController
   
-  def simulate_request!
-    @controller.instance_eval { @apotomo_request_processor = nil }
+  class KidWidget < MouseWidget
+    responds_to_event :squeak, :passing => :root
+    
+    def feed
+      render  # invokes #url_for_event.
+    end
+    
+    def squeak
+      render :text => "squeak!"
+    end
   end
   
+  
+  class MumWidget < MouseWidget
+    responds_to_event :squeak
+    responds_to_event :sniff
+    
+    has_widgets do |me|
+      me << widget("rails_integration_test/kid", :kid)
+    end
+    
+    def eat
+      render
+    end
+    
+    def make_me_squeak
+      render
+    end
+    
+    def squeak(evt) 
+      render :text => evt.data
+    end
+    
+    def sniff(evt)
+      render :text => "<b>sniff sniff</b>"
+    end
+    
+    def child
+      render :text => render_widget(:kid, :feed)
+    end
+  end
+  
+  
   context "ActionController" do
     setup do
-      @mum = mum = MouseWidget.new(parent_controller, 'mum', :eating)
-      @mum.instance_eval do
-        def eating; render; end
-      end
-      
-      @mum.respond_to_event :squeak
-      
       @controller.class.has_widgets do |root|
-        root << mum
+        MumWidget.new(root, 'mum')
       end
       
       @controller.instance_eval do
         def mum
-          render :text => render_widget('mum', :eat)
+          render :text => render_widget('mum', params[:state])
         end
       end
     end
     
     should "provide the rails view helpers in state views" do
-      @mum.instance_eval do
-        def eat; render :view => :make_me_squeak; end
-      end
-      
-      get 'mum'
+      get 'mum', :state => :make_me_squeak
       assert_select "a", "mum"
     end
     
-    should "pass the event with all params data as state-args" do
-      @mum.instance_eval do
-        def squeak(evt); render :text => evt.data; end
+    context "nested widgets" do
+      should "render" do
+        get 'mum', :state => :child
+        assert_equal "/barn/render_event_response?source=kid&amp;type=click\n", @response.body
       end
       
+      should "process events" do
+        get 'render_event_response', :source => 'root', :type => :squeak
+        assert_equal "squeak!", @response.body
+      end
+    end
+    
+    should "pass the event with all params data as state-args" do
       get 'render_event_response', :source => 'mum', :type => :squeak, :pitch => :high
-      assert_equal "{\"source\"=>\"mum\", \"type\"=>\"squeak\", \"pitch\"=>\"high\", \"controller\"=>\"barn\", \"action\"=>\"render_event_response\"}", @response.body
+      assert_equal "{\"source\"=>\"mum\", \"type\"=>\"squeak\", \"pitch\"=>\"high\", \"controller\"=>\"barn\", \"action\"=>\"render_event_response\"}\nsqueak!", @response.body
     end
     
     should "render updates to the parent window for an iframe request" do
-      @mum.instance_eval do
-        def squeak(evt); render :text => "<b>SQUEAK!</b>"; end
-      end
-      
-      get 'mum'
-      assert_response :success
-      
-      simulate_request!
-      
-      get 'render_event_response', :source => 'mum', :type => :squeak, :apotomo_iframe => true
+      get 'render_event_response', :source => 'mum', :type => :sniff, :apotomo_iframe => true
       
       assert_response :success
       assert_equal 'text/html', @response.content_type
-      assert_equal "<html><body><script type='text/javascript' charset='utf-8'>\nvar loc = document.location;\nwith(window.parent) { setTimeout(function() { window.eval('<b>SQUEAK!<\\/b>'); window.loc && loc.replace('about:blank'); }, 1) }\n</script></body></html>", @response.body
+      assert_equal "<html><body><script type='text/javascript' charset='utf-8'>\nvar loc = document.location;\nwith(window.parent) { setTimeout(function() { window.eval('<b>sniff sniff<\\/b>'); window.loc && loc.replace('about:blank'); }, 1) }\n</script></body></html>", @response.body
     end
     
     

data/test/rails/view_helper_test.rb

@@ -66,14 +66,16 @@ class ViewHelperTest < Apotomo::TestCase
     end
     
     should "respond to #render_widget" do
-      mum = mouse_mock 
-      mum << mouse_mock('kid')
+      mum = mouse
+      MouseWidget.new(mum, :kid)
+      
       assert_equal("<div id=\"kid\">burp!</div>\n", in_view(mum){ render_widget 'kid', :eat })
     end
     
     should "respond to #children" do
-      mum = mouse_mock 
-      mum << mouse_mock('kid')
+      mum = mouse
+      MouseWidget.new(mum, :kid)
+      
       assert_equal("<div id=\"kid\">burp!</div>\n", in_view(mum) do
         children.inject("") { |html, child| html += render_widget(child, :eat) }.html_safe
       end)

data/test/{unit/render_test.rb → render_test.rb}

@@ -5,7 +5,7 @@ class RenderTest < ActionView::TestCase
   
   context "#render" do
     setup do
-      @mum = mouse_mock('mum', :eating)
+      @mum = mouse('mum')
     end
     
     should "per default display the state content framed in a div" do
@@ -31,7 +31,7 @@ class RenderTest < ActionView::TestCase
     end
     
     should "expose its instance variables in the rendered view" do
-      @mum = mouse_mock('mum', :educate) do
+      @mum = mouse('mum') do
         def educate
           @who  = "the cat"
           @what = "run away"
@@ -41,12 +41,12 @@ class RenderTest < ActionView::TestCase
       assert_equal 'If you see the cat do run away!', @mum.invoke(:educate)
     end
     
-    context "with #emit" do
+    context "with #render" do
       context "and :text" do
         setup do
           @mum.instance_eval do
             def squeak
-              emit :text => "squeak();"
+              render :text => "squeak();"
             end
           end
         end
@@ -60,7 +60,7 @@ class RenderTest < ActionView::TestCase
         setup do
           @mum.instance_eval do
             def squeak
-              emit
+              render
             end
           end
         end
@@ -74,7 +74,7 @@ class RenderTest < ActionView::TestCase
         setup do
           @mum.instance_eval do
             def squeak
-              emit :view => :eating
+              render :view => :eating
             end
           end
         end

data/test/{unit/request_processor_test.rb → request_processor_test.rb}

@@ -72,8 +72,9 @@ class RequestProcessorTest < ActiveSupport::TestCase
         def squeak; render :text => "squeak!"; end
       end
   
-      procs = [Proc.new{ |root,controller| 
-        root << widget(:mouse, 'mum') << KidWidget.new(parent_controller, 'kid', :squeak)
+      procs = [Proc.new{ |root| 
+        root << widget(:mouse, 'mum') 
+          KidWidget.new(root['mum'], 'kid')
       }]
     
       @processor = Apotomo::RequestProcessor.new(parent_controller, {:js_framework => :prototype}, procs)
@@ -138,36 +139,40 @@ class RequestProcessorHooksTest < ActiveSupport::TestCase
   
   context "Hooks in RequestProcessor" do
     setup do
+      @kid = mouse_mock(:kid)
       @class = Class.new(Apotomo::RequestProcessor)
+      @class.instance_eval do
+        def kid=(kid); @kid=kid end
+        def kid; @kid end
+      end
+      @class.kid = @kid
     end
     
     context ":after_initialize hook" do
       should "be called after the has_widgets blocks invokation" do
-        @k = mouse_mock("kid")
         @class.after_initialize do |r|
-          r.root["mum"] << @k
+          r.root[:mum] << self.class.kid # requires that :mum is there, yet.
         end
         
         @r = @class.new(parent_controller, {}, 
-          [Proc.new { |root| root << widget(:mouse, 'mum') }])
+          [Proc.new { |root| root << widget(:mouse, :mum) }])
         
-        assert_equal @r.root["mum"]["kid"], @k
+        assert @r.root[:mum][:kid]
       end
     end
     
     context ":after_fire hook" do
       should "be called in #process_for after fire" do
-        @k = mouse_mock("kid")
         @class.after_fire do |r|
-          r.root["mum"] << @k = mouse_mock("kid")
+          r.root[:mum] << self.class.kid
         end
         
         # DISCUSS: maybe add a trigger test here?
         @r = @class.new(parent_controller, {}, 
-          [Proc.new { |root| root << widget(:mouse, 'mum') }])
+          [Proc.new { |root| root << widget(:mouse, :mum) }])
         @r.process_for(:source => "root", :type => :noop) # calls ~after_fire.
         
-        assert_equal @k, @r.root["mum"]["kid"]
+        assert @r.root[:mum][:kid]
       end
     end
   end

data/test/test_case_methods.rb

@@ -1,10 +1,22 @@
 module Apotomo
   module TestCaseMethods
+    def root_mock
+      MouseWidget.new(parent_controller, :root)
+    end
+    
+    def mouse(id=nil, &block)
+      MouseWidget.new(parent_controller, id || :mouse).tap do |widget|
+        widget.instance_eval &block if block_given?
+      end
+    end
+    
+    
     # Provides a ready-to-use mouse widget instance.
     def mouse_mock(id='mouse', opts={}, &block)
-      mouse = MouseWidget.new(parent_controller, id, opts)
-      mouse.instance_eval &block if block_given?
-      mouse
+      #mouse = MouseWidget.new(parent_controller, id, opts)
+      #mouse.instance_eval &block if block_given?
+      widget(:mouse, id, opts)
+      #mouse
     end
     
     def mouse_class_mock(&block)
@@ -14,8 +26,9 @@ module Apotomo
     end
     
     def mum_and_kid!
-      @mum = mouse_mock('mum')
-        @mum << @kid = mouse_mock('kid')
+      @mum = mouse('mum')
+        @kid = MouseWidget.new(@mum, 'kid')
+      
       
       @mum.respond_to_event :squeak, :with => :answer_squeak
       @mum.respond_to_event :squeak, :from => 'kid', :with => :alert

data/test/test_helper.rb

@@ -40,10 +40,6 @@ module Farm
   end
 end
 
-class MouseWidget < Apotomo::Widget
-end
-
-
 class MouseWidget < Apotomo::Widget
   def squeak
     render :text => "squeak!"

data/test/tree_node_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class TreeNodeTest < ActiveSupport::TestCase
+  context "initialization" do
+    setup do
+      
+    end
+    
+    should "return true for #root? without parent" do
+      assert MouseWidget.new(nil, :mum).root?
+    end
+    
+    should "return false for #root? with parent" do
+      @mum = MouseWidget.new(nil, :mum)
+      assert_not MouseWidget.new(@mum, :kid).root?
+    end
+    
+  end
+end

data/test/widget_shortcuts_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+class MumWidget < MouseWidget; end
+class MouseTabsWidget;end
+
+class WidgetShortcutsTest < Test::Unit::TestCase
+  context "FactoryProxy" do
+    setup do
+      @factory = Apotomo::WidgetShortcuts::FactoryProxy
+    end
+    
+    context "#constant_for" do
+      setup do
+        @dsl = @factory.new(:class, :id)
+      end
+      
+      should "constantize symbols" do
+        assert_equal MouseWidget, @dsl.send(:constant_for, :mouse)
+      end
+  
+      should "not try to singularize the widget class" do
+        assert_equal MouseTabsWidget, @dsl.send(:constant_for, :mouse_tabs)
+      end
+    end
+    
+    context "#widget and #<<" do
+      setup do
+        @root = Apotomo::Widget.new(nil, :root)
+      end
+        
+      context "with all arguments" do
+        should "create a MumWidget instance with options" do
+          proxy = widget(:mum, :mummy, :eating, :color => 'grey', :type => :hungry)
+          @root << proxy
+          
+          assert_kind_of MumWidget, @root[:mummy]
+          assert_equal :mummy, @root[:mummy].name
+          assert_equal({:color => "grey", :type => :hungry}, @root[:mummy].options)
+        end
+      end
+    
+      should "not set options with 2 arguments" do
+        @root << widget(:mum, :mummy)
+        @mum = @root[:mummy]
+        
+        assert_kind_of MumWidget, @mum
+        assert_equal :mummy, @mum.widget_id
+        assert_equal({}, @mum.options)
+      end
+    
+      should "set defaults with prefix, only" do
+        @root << widget(:mum)
+        @mum = @root[:mum]
+        
+        assert_kind_of MumWidget, @mum
+        assert_equal :mum, @mum.name
+        assert_equal({}, @mum.options)
+      end
+      
+      should "yield itself" do
+        ficken = widget(:mum) do |mum|
+          mum << widget(:mouse, :kid)
+        end
+        @root << ficken
+        assert_equal 2, @root[:mum].size
+        assert_kind_of MouseWidget, @root[:mum][:kid]
+      end
+    end
+  end
+end

data/test/{unit/widget_test.rb → widget_test.rb}

@@ -14,51 +14,27 @@ class WidgetTest < ActiveSupport::TestCase
     setup do
       @mum = Class.new(MouseWidget) do
         has_widgets do |me|
-          me << widget(:mouse, 'baby')
+          me << widget(:mouse, :baby)
+          #MouseWidget.new(me, :baby) # this is also possible.
         end
       end.new(@controller, 'mum')
       
-      @kid = Class.new(@mum.class).new(@controller, 'mum', :squeak)
+      @kid = Class.new(@mum.class).new(@controller, 'mum')
     end
     
     should "setup the widget family at creation time" do
       assert_equal 1, @mum.children.size
-      assert_kind_of Apotomo::Widget, @mum['baby']
+      assert_kind_of MouseWidget, @mum[:baby]
     end
     
     should "inherit trees for now" do
       assert_equal 1, @mum.children.size
-      assert_kind_of Apotomo::Widget, @mum['baby']
+      assert_kind_of MouseWidget, @mum[:baby]
     end
   end
   
-  context "Widget.after_add" do
-    setup do
-      @mum = Class.new(MouseWidget) do
-        after_add do |me, parent|
-          parent << widget(:mouse, 'kid', :squeak)
-        end
-      end.new(@controller, 'mum', :squeak)
-      
-      @root = mouse_mock('root')
-    end
-    
-    should "be invoked after mum is added" do
-      assert_equal [], @root.children
-      @root << @mum
-      
-      assert_equal ['mum', 'kid'], @root.children.collect { |w| w.name }
-    end
-    
-    should "inherit callbacks" do
-      @berry = Class.new(@mum.class).new(@controller, 'berry', :squeak)
-      @root << @berry
-      
-      assert_equal ['berry', 'kid'], @root.children.collect { |w| w.name }
-    end
-  end
-
-  context "A stateless widget" do
+  
+  context "A widget" do
     setup do
       @mum = Apotomo::Widget.new(@controller, 'mum', :squeak)
     end
@@ -119,22 +95,18 @@ class WidgetTest < ActiveSupport::TestCase
       assert_respond_to @mum, :widget
     end
     
-    should "respond to #parent_controller" do
+    should "respond to #parent_controller and return the AC in root" do
+      @mum << mouse_mock(:kid)
       assert_equal @controller, @mum.parent_controller
+      assert_equal @controller, @mum[:kid].parent_controller
     end
     
     should "alias #widget_id to #name" do
       assert_equal @mum.name, @mum.widget_id
     end
     
-    should "mark #param as deprecated" do
-      assert_raises RuntimeError do
-        @mum.param(:volume)
-      end
-    end
-    
     should "respond to DEFAULT_VIEW_PATHS" do
-      assert_equal ["app/widgets", "app/widgets/layouts"], Apotomo::Widget::DEFAULT_VIEW_PATHS
+      assert_equal ["app/widgets"], Apotomo::Widget::DEFAULT_VIEW_PATHS
     end
     
     should "respond to .view_paths" do
@@ -167,47 +139,47 @@ end
 
 class RenderWidgetTest < ActiveSupport::TestCase
   include Apotomo::TestCaseMethods::TestController
-
+  
   context "#render_widget" do
     should "allow passing widget id" do
-      assert_equal "squeak!", mouse_mock.render_widget('mouse', :squeak)
+      assert_equal "squeak!", mouse.render_widget('mouse', :squeak)
     end
     
     should "allow passing widget instance" do
-      assert_equal 'squeak!', mouse_mock.render_widget(mouse_mock('mum'), :squeak)
+      assert_equal 'squeak!', mouse.render_widget(mouse(:mum), :squeak)
     end
     
     should "use :display as standard state" do
-      mum = mouse_mock('Mum') do
+      mum = mouse('Mum') do
         def display
           render :text => "#{widget_id}, that's me!"
         end
       end
       
-      assert_equal "Mum, that's me!", mouse_mock.render_widget(mum)
+      assert_equal "Mum, that's me!", mouse.render_widget(mum)
     end
     
     should "raise an exception when a non-existent widget id is passed" do
       e = assert_raises RuntimeError do
-        mouse_mock.render_widget('mummy')
+        mouse.render_widget('mummy')
       end
       
       assert_equal "Couldn't render non-existent widget `mummy`", e.message
     end
     
     should "pass options as state-args" do
-      mum = mouse_mock do
+      mum = mouse do
         def display(color="grey")
           render :text => "I'm #{color}"
         end
       end
       
-      assert_equal("I'm grey", mouse_mock.render_widget(mum), "default value in state-arg didn't work")
-      assert_equal("I'm black", mouse_mock.render_widget(mum, :display, "black"))
+      assert_equal("I'm grey", mouse.render_widget(mum), "default value in state-arg didn't work")
+      assert_equal("I'm black", mouse.render_widget(mum, :display, "black"))
     end
     
     should "use #find_widget from self to find the passed widget id" do
-      mum = mouse_mock('mum') << mouse_mock(:kid)
+      mum = mouse << mouse_mock(:kid)
       
       assert_equal "<div id=\"kid\">burp!</div>\n", mum.render_widget(:kid, :eat)
     end 

data/test/widgets/mouse/feed.html.erb

@@ -1 +1 @@
-<%= rendered_children.collect{|v| v.last}.join("\n")
+<%= url_for_event :click %>

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 1
-  - 4
-  version: 1.1.4
+  - 2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-28 00:00:00 +02:00
+date: 2011-10-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,9 +57,9 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 1
-        - 3
-        version: 0.1.3
+        - 2
+        - 0
+        version: 0.2.0
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -176,6 +176,7 @@ files:
 - lib/generators/templates/widget.rb
 - lib/generators/templates/widget_test.rb
 - lib/generators/test_unit/widget_generator.rb
+- test/apotomo_test.rb
 - test/dummy/Rakefile
 - test/dummy/app/controllers/application_controller.rb
 - test/dummy/app/helpers/application_helper.rb
@@ -201,30 +202,29 @@ files:
 - test/dummy/public/500.html
 - test/dummy/public/favicon.ico
 - test/dummy/public/stylesheets/.gitkeep
+- test/event_handler_test.rb
+- test/event_methods_test.rb
+- test/event_test.rb
+- test/javascript_generator_test.rb
+- test/onfire_integration_test.rb
 - test/rails/caching_test.rb
 - test/rails/controller_methods_test.rb
 - test/rails/rails_integration_test.rb
 - test/rails/view_helper_test.rb
 - test/rails/widget_generator_test.rb
+- test/render_test.rb
+- test/request_processor_test.rb
 - test/test_case_methods.rb
+- test/test_case_test.rb
 - test/test_helper.rb
-- test/unit/apotomo_test.rb
-- test/unit/event_handler_test.rb
-- test/unit/event_methods_test.rb
-- test/unit/event_test.rb
-- test/unit/javascript_generator_test.rb
-- test/unit/onfire_integration_test.rb
-- test/unit/render_test.rb
-- test/unit/request_processor_test.rb
-- test/unit/test_case_test.rb
-- test/unit/widget_shortcuts_test.rb
-- test/unit/widget_test.rb
+- test/tree_node_test.rb
+- test/widget_shortcuts_test.rb
+- test/widget_test.rb
 - test/widgets/mouse/eat.erb
 - test/widgets/mouse/eating.html.erb
 - test/widgets/mouse/educate.html.erb
 - test/widgets/mouse/feed.html.erb
 - test/widgets/mouse/make_me_squeak.html.erb
-- test/widgets/mouse/posing.html.erb
 - test/widgets/mouse/snuggle.html.erb
 has_rdoc: true
 homepage: http://github.com/apotonick/apotomo

data/test/unit/widget_shortcuts_test.rb

@@ -1,76 +0,0 @@
-require 'test_helper'
-
-class MumWidget < MouseWidget; end
-class MouseTabsWidget;end
-
-class WidgetShortcutsTest < Test::Unit::TestCase
-  include Apotomo::TestCaseMethods::TestController
-  
-  context "#constant_for" do
-    should "constantize symbols" do
-      assert_equal MumWidget, constant_for(:mum)
-    end
-    
-    should "not try to singularize the widget class" do
-      assert_equal MouseTabsWidget, constant_for(:mouse_tabs)
-    end
-  end
-  
-  context "#widget" do   
-    context "with all arguments" do
-      setup do
-        @mum = widget(:mum, 'mum', :eating, :color => 'grey', :type => :hungry)
-      end
-      
-      should "create a MumWidget instance" do
-        assert_kind_of MumWidget, @mum
-        assert_equal 'mum', @mum.name
-      end
-      
-      should "accept options" do
-        assert_equal({:color => "grey", :type => :hungry}, @mum.options)
-      end
-    end
-    
-    context "with 3 arguments and no options" do
-      should "not set options" do
-        @mum = widget(:mum, 'mum', :squeak)
-        assert_kind_of MumWidget, @mum
-        assert_equal 'mum',     @mum.name
-        assert_equal({},        @mum.options)
-      end
-    end
-    
-    context "with class and id" do
-      setup do
-        @mum = widget(:mum, 'mummy')
-      end
-      
-      should "create a MumWidget instance" do
-        assert_kind_of MumWidget, @mum
-        assert_equal 'mummy', @mum.name
-      end
-    end
-    
-    context "with class, only" do
-      setup do
-        @mum = widget(:mum)
-      end
-      
-      should "create a MumWidget instance named :mum" do
-        assert_kind_of MumWidget, @mum
-        assert_equal :mum, @mum.name
-      end
-    end
-    
-    
-    should "yield itself" do
-      @mum = widget(:mum, 'mum') do |mum|
-        assert_kind_of MumWidget, mum
-        mum << widget(:mum, 'kid')
-      end
-      assert_equal 2, @mum.size
-      assert_kind_of MumWidget, @mum['kid']
-    end
-  end
-end

data/test/widgets/mouse/posing.html.erb

@@ -1 +0,0 @@
-<%= rendered_children.collect{|e| e.last}.join("") %>