apotomo 1.0.5 → 1.1.0.rc1

data/lib/apotomo/widget/javascript_methods.rb

@@ -0,0 +1,39 @@
+module Apotomo
+  module JavascriptMethods
+    # Wraps the rendered content in a replace statement targeted at your +Apotomo.js_framework+ setting.
+    # Use +:selector+ to change the selector.
+    #
+    # Example:
+    #
+    # Assuming you set 
+    #   Apotomo.js_framework = :jquery
+    #
+    # and call replace in a state
+    #
+    #   replace :view => :squeak, :selector => "div#mouse"
+    #   #=> "$(\"div#mouse\").replaceWith(\"<div id=\\\"mum\\\">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.
+    #
+    # Example for +:jquery+:
+    #
+    #   update :view => :squeak
+    #   #=> "$(\"mum\").html(\"<div id=\\\"mum\\\">squeak!<\\/div>\")"
+    def update(*args)
+      wrap_in_javascript_for(:update, *args)
+    end
+    
+  private
+    def wrap_in_javascript_for(mode, *args)
+      content = render(*args)
+      options = args.first.is_a?(::Hash) ? args.shift : {}
+      
+      options[:selector] ? 
+        Apotomo.js_generator.send(mode, options[:selector], content) :  # replace(:twitter)
+        Apotomo.js_generator.send("#{mode}_id", name, content)          # replace_id(:twitter)
+    end
+  end
+end

data/lib/apotomo/widget_shortcuts.rb

@@ -1,59 +1,33 @@
 module Apotomo
   # Shortcut methods for creating widget trees.
   module WidgetShortcuts
-    # Shortcut for creating an instance of +class_name+ named +id+.
-    # If +start_state+ is omited, :display is default. Yields self.
+    # Shortcut for creating an instance of <tt>class_name+"_widget"</tt> named +id+. Yields self.
     #
     # Example:
     # 
-    #   widget(:comments_widget, 'post-comments')
-    #   widget(:comments_widget, 'post-comments', :user => @current_user)
-    #
-    # Start state is <tt>:display</tt>, whereas the latter also populates @opts.
+    #   widget(:comments)
+    # 
+    # will create a +CommentsWidget+ with id :comments.
     #
-    #   widget(:comments_widget, 'post-comments', :reload)
-    #   widget(:comments_widget, 'post-comments', :reload, :user => @current_user)
+    #   widget(:comments, 'post-comments', :user => current_user)
     #
-    # Explicitely sets the start state.
+    # sets id to 'posts_comments' and #options to the hash.
     #
     # You can also use namespaces.
     #
     #   widget('jquery/tabs', 'panel')
-    def widget(class_name, id, state=:display, *args)
-      if state.kind_of?(Hash)
-        args << state
-        state = :display
-      end
+    def widget(prefix, *args)
+      options = args.extract_options!
+      id      = args.shift || prefix
       
-      object = constant_for(class_name).new(parent_controller, id, state, *args)
-      yield object if block_given?
-      object
-    end
-    
-    def container(id, *args, &block)
-      widget('apotomo/container_widget', id, *args, &block)
-    end
-    
-    def section(*args)
-      container(*args)
-    end
-    
-    # TODO: deprecate.
-    def cell(base_name, states, id, *args)
-      widget(base_name.to_s + '_cell', states, id, *args)
-    end
-    
-    def tab_panel(id, *args)
-      widget('apotomo/tab_panel_widget', :display, id, *args)
-    end
-    
-    def tab(id, *args)
-      widget('apotomo/tab_widget', :display, id, *args)
+      constant_for(prefix).new(parent_controller, id, options).tap do |object|
+        yield object if block_given?  
+      end
     end
     
     private
-      def constant_for(class_name)
-        class_name.to_s.camelize.constantize
+      def constant_for(class_name)  # TODO: use Cell.class_from_cell_name. 
+        "#{class_name}_widget".classify.constantize
       end
   end
 end

data/lib/generators/apotomo/widget_generator.rb

@@ -1,19 +1,18 @@
-require 'generators/cells/cell_generator'
+require 'generators/cells/base'
 
 module Apotomo
   module Generators
-    class WidgetGenerator < Cells::Generators::CellGenerator
-      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+    class WidgetGenerator < ::Cells::Generators::Base
+      source_root File.expand_path(File.join(File.dirname(__FILE__), '../templates'))
       
       def create_cell_file
-        puts "creating #{file_name}.rb"
-        template 'widget.rb', File.join('app/cells', class_path, "#{file_name}.rb")
+        template 'widget.rb', File.join('app/widgets', class_path, "#{file_name}_widget.rb")
       end
       
-      def create_test
-        @states = actions
-        template 'widget_test.rb', File.join('test/widgets/', "#{file_name}_test.rb")
-      end
+      check_class_collision :suffix => "Widget"
+      
+      hook_for(:template_engine)
+      hook_for(:test_framework)  # TODO: implement rspec-apotomo.
     end
   end
 end

data/lib/generators/erb/widget_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/cells/base'
+
+module Erb
+  module Generators
+    class WidgetGenerator < ::Cells::Generators::Base
+      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

@@ -0,0 +1,20 @@
+require 'generators/cells/base'
+
+module Haml
+  module Generators
+    class WidgetGenerator < ::Cells::Generators::Base
+      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/{apotomo/templates → templates}/view.erb

@@ -1,5 +1,5 @@
 <h1>
-  <%= class_name %>#<%= @state %>
+  <%= class_name %>Widget#<%= @state %>
 </h1>
 
 <p>

data/lib/generators/templates/view.haml

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

data/lib/generators/{apotomo/templates → templates}/widget.rb

@@ -1,4 +1,4 @@
-class <%= class_name %> < Apotomo::Widget
+class <%= class_name %>Widget < Apotomo::Widget
 
 <% for action in actions -%>
   def <%= action %>

data/lib/generators/{apotomo/templates → templates}/widget_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class <%= class_name %>Test < Apotomo::TestCase
+class <%= class_name %>WidgetTest < Apotomo::TestCase
   has_widgets do |root|
     root << widget(:<%= file_name %>, 'me')
   end

data/lib/generators/test_unit/widget_generator.rb

@@ -0,0 +1,14 @@
+require 'generators/cells/base'
+
+module TestUnit
+  module Generators
+    class WidgetGenerator < ::Cells::Generators::Base
+      source_root File.expand_path('../../templates', __FILE__)
+
+      def create_test
+        @states = actions
+        template 'widget_test.rb', File.join('test/widgets/', "#{file_name}_widget_test.rb")
+      end
+    end
+  end
+end

data/test/rails/caching_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-
+# TODO: assert that same-named cells and widgets don't overwrite their caches.
 
 class CachingTest < ActiveSupport::TestCase
   include Apotomo::TestCaseMethods::TestController
@@ -8,31 +8,24 @@ class CachingTest < ActiveSupport::TestCase
   class CheeseWidget < Apotomo::Widget
     cache :holes
     
-    @@holes = 0
-    cattr_accessor :holes
-    
-    
-    #def self.reset!
-    #  @@counter = 0
-    #end
-    
-    def increment!
-      self.class.holes += 1
-    end
-    
-    def holes
-      render :text => increment!
+    def holes(count)
+      render :text => count
     end 
   end
   
   context "A caching widget" do
     setup do
+      ActionController::Base.perform_caching = true
       @cheese = CheeseWidget.new(parent_controller, 'cheese', :holes)
     end
     
+    teardown do
+      ActionController::Base.perform_caching = false
+    end
+    
     should "invoke the cached state only once" do
-      assert_equal "1", @cheese.invoke
-      assert_equal "1", @cheese.invoke
+      assert_equal "1", @cheese.invoke(:holes, 1)
+      assert_equal "1", @cheese.invoke(:holes, 2)
     end
   end
 end

data/test/rails/controller_methods_test.rb

@@ -16,7 +16,7 @@ class ControllerMethodsTest < ActionController::TestCase
     end
     
     context "responding to #apotomo_request_processor" do
-      should "initially return the processor which has a flushed root" do
+      should "initially return the processor which has an empty root" do
         assert_kind_of Apotomo::RequestProcessor, @controller.apotomo_request_processor
         assert_equal 1, @controller.apotomo_request_processor.root.size
       end
@@ -29,7 +29,7 @@ class ControllerMethodsTest < ActionController::TestCase
     context "invoking #has_widgets" do
       setup do
         @controller.class.has_widgets do |root|
-          root << widget(:mouse_cell, 'mum')
+          root << widget(:mouse, 'mum')
         end
       end
       
@@ -44,7 +44,7 @@ class ControllerMethodsTest < ActionController::TestCase
       
       should "allow multiple calls to has_widgets" do
         @controller.class.has_widgets do |root|
-          root << widget(:mouse_cell, 'kid')
+          root << widget(:mouse, 'kid')
         end
         
         assert @controller.apotomo_root['mum']
@@ -52,7 +52,7 @@ class ControllerMethodsTest < ActionController::TestCase
       end
       
       should "inherit has_widgets blocks to sub-controllers" do
-        berry = widget(:mouse_cell, 'berry')
+        berry = widget(:mouse, 'berry')
         @sub_controller = Class.new(@controller.class) do
           has_widgets { |root| root << berry }
         end.new
@@ -68,88 +68,34 @@ class ControllerMethodsTest < ActionController::TestCase
         end
         
         @controller.class.has_widgets do |root|
-          root << widget(:mouse_cell, 'kid', :display, :roomies => roomies)
+          root << widget(:mouse, 'kid', :display, :roomies => roomies)
         end
         
-        assert_equal ['mice', 'cows'], @controller.apotomo_root['kid'].opts[:roomies]
+        assert_equal ['mice', 'cows'], @controller.apotomo_root['kid'].options[:roomies]
       end
     end
     
-    context "invoking #use_widgets" do
-      should "have an empty apotomo_root if no call happened, yet" do
-        assert_equal [],  @controller.bound_use_widgets_blocks
-        assert_equal 1,   @controller.apotomo_root.size
-      end
-      
-      should "extend the widget family and remember the block with one #use_widgets call" do
-        @controller.use_widgets do |root|
-          root << widget(:mouse_cell, 'mum')
-        end
-        
-        assert_equal 1, @controller.bound_use_widgets_blocks.size
-        assert_equal 2, @controller.apotomo_root.size
-      end
-      
-      should "add blocks only once" do
-        block = Proc.new {|root| root << widget(:mouse_cell, 'mum')}
-        
-        @controller.use_widgets &block
-        @controller.use_widgets &block
-        
-        assert_equal 1, @controller.bound_use_widgets_blocks.size
-        assert_equal 2, @controller.apotomo_root.size
-      end
-      
-      should "allow multiple calls with different blocks" do
-        mum_and_kid!
-        @controller.use_widgets do |root|
-          root << @mum
-        end
-        @controller.use_widgets do |root|
-          root << widget(:mouse_cell, 'pet')
-        end
-        
-        assert_equal 2, @controller.bound_use_widgets_blocks.size
-        assert_equal 4, @controller.apotomo_root.size
-      end
-    end
+    
     
     context "invoking #url_for_event" do
       should "compute an url for any widget" do
         assert_equal "/barn/render_event_response?source=mouse&type=footsteps&volume=9", @controller.url_for_event(:footsteps, :source => :mouse, :volume => 9)
       end
     end
-    
-    should "flush its bound_use_widgets_blocks with, guess, #flush_bound_use_widgets_blocks" do
-      @controller.bound_use_widgets_blocks << Proc.new {}
-      assert_equal 1, @controller.bound_use_widgets_blocks.size
-      @controller.flush_bound_use_widgets_blocks
-      assert_equal 0, @controller.bound_use_widgets_blocks.size
-    end 
   end
   
   context "invoking #render_widget" do
     setup do
-      @mum = mouse_mock('mum', 'snuggle') {def snuggle; render; end}
+      @mum = mouse_mock('mum', 'eating')
     end
     
     should "render the widget" do
       @controller.apotomo_root << @mum
-      assert_equal "<div id=\"mum\"><snuggle></snuggle></div>\n", @controller.render_widget('mum')
+      assert_equal "<div id=\"mum\">burp!</div>\n", @controller.render_widget('mum', :eat)
     end
   end
   
   
-  
-  context "invoking #apotomo_freeze" do
-    should "freeze the widget tree to session" do
-      assert_equal 0, @controller.session.size
-      @controller.send :apotomo_freeze
-      assert @controller.session[:apotomo_widget_ivars]
-      assert @controller.session[:apotomo_stateful_branches]
-    end
-  end
-    
   context "processing an event request" do
     setup do
       @mum = mouse_mock('mum', :eating)
@@ -180,24 +126,6 @@ class ControllerMethodsTest < ActionController::TestCase
     end
   end
   
-  context "The ProcHash" do
-    setup do
-      @procs = Apotomo::Rails::ControllerMethods::ProcHash.new
-      @b = Proc.new{}; @d = Proc.new{}
-      @c = Proc.new{}
-      @procs << @b
-    end
-    
-    should "return true for procs it includes" do
-      assert @procs.include?(@b)
-      assert @procs.include?(@d)  ### DISCUSS: line nr is id, or do YOU got a better idea?!
-    end
-    
-    should "reject unknown procs" do
-      assert ! @procs.include?(@c)
-    end
-  end
-  
   ### FIXME: could somebody get that working?
   context "Routing" do
     should_eventually "generate routes to the render_event_response action" do

data/test/rails/rails_integration_test.rb

@@ -1,90 +1,55 @@
 require 'test_helper'
 
 class RailsIntegrationTest < ActionController::TestCase
+  include Apotomo::TestCaseMethods::TestController
+  
   def simulate_request!
     @controller.instance_eval { @apotomo_request_processor = nil }
-    
-    ### FIXME: @controller.session = Marshal.load(Marshal.dump(@controller.session))
   end
   
-  include Apotomo::TestCaseMethods::TestController
-  
-  context "A Rails controller" do
+  context "ActionController" do
     setup do
-      @mum = MouseCell.new(parent_controller, 'mum', :snuggle)
-      @mum.class.class_eval do
-        responds_to_event :squeak, :with => :snuggle
-        
-        def snuggle; render; end
+      @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
       end
       
-      @controller.instance_variable_set(:@mum, @mum)
       @controller.instance_eval do
         def widget
-          use_widgets do |root|
-            root << @mum
-          end
-          
-          render :text => render_widget('mum')
+          render :text => render_widget('mum', :eat)
         end
       end
     end
     
-    should "freeze the widget tree once after each request" do
-      assert_equal 0, @controller.session.size
-      
-      get 'widget'
-      assert_equal 1, @controller.session[:apotomo_stateful_branches].size
-    end
-    
-    should "invoke a #use_widgets block only once per session" do
-      #assert_equal 1, @controller.apotomo_root.size
-      
-      get 'widget'
-      assert_response :success
-      assert_equal 1, @controller.session[:apotomo_stateful_branches].size
-      
-      simulate_request!
-      
-      get 'widget'
-      assert_equal 1, @controller.session[:apotomo_stateful_branches].size
-      assert_response :success
-      
-      simulate_request!
-      
-      get 'widget'
-      assert_response :success
-      assert_equal 2, @controller.apotomo_root.size, "mum added multiple times"
-    end
-    
     should "provide the rails view helpers in state views" do
       @mum.instance_eval do
-        def snuggle; render :view => :make_me_squeak; end
+        def eat; render :view => :make_me_squeak; end
       end
       
       get 'widget'
       assert_select "a", "mum"
     end
     
-    should "contain a freshly flushed tree when ?flush_widgets=1 is set" do
-      get 'widget'
-      assert_response :success
-      assert @controller.apotomo_request_processor.widgets_flushed?
-      
-      simulate_request!
-      
-      get 'widget'
-      assert_response :success
-      assert_not @controller.apotomo_request_processor.widgets_flushed?
-      
-      simulate_request!
+    should "pass the event with all params data as state-args" do
+      @mum.instance_eval do
+        def squeak(evt); render :text => evt.data; end
+      end
       
-      get 'widget', :flush_widgets => 1
-      assert_response :success  # will fail if no #use_widgets block invoked
-      assert @controller.apotomo_request_processor.widgets_flushed?
+      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
     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 'widget'
       assert_response :success
       
@@ -94,7 +59,58 @@ class RailsIntegrationTest < ActionController::TestCase
       
       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('<div id=\\\"mum\\\"><snuggle><\\/snuggle><\\/div>\\n'); 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>SQUEAK!<\\/b>'); window.loc && loc.replace('about:blank'); }, 1) }\n</script></body></html>", @response.body
+    end
+    
+    
+    context "ActionView" do  
+      setup do
+        @controller.instance_eval do
+          def widget
+            render :inline => "<%= render_widget 'mum', :eat %>"
+          end
+        end
+      end
+      
+      should "respond to #render_widget" do
+        get :widget
+        assert_select "#mum", "burp!"
+      end
+      
+      should "respond to #url_for_event" do
+        @controller.instance_eval do
+          def widget
+            render :inline => "<%= url_for_event :footsteps, :source => 'mum' %>"
+          end
+        end
+        
+        get :widget
+        assert_equal "/barn/render_event_response?source=mum&amp;type=footsteps", @response.body
+      end
+    end
+  end
+end
+
+
+class IncludingApotomoSupportTest < ActiveSupport::TestCase
+  context "A controller not including ControllerMethods explicitely" do
+    setup do
+      @class      = Class.new(ActionController::Base)
+      @controller = @class.new
+      @controller.request = ActionController::TestRequest.new
+    end
+    
+    should "respond to .has_widgets only" do
+      assert_respond_to @class, :has_widgets
+      assert_not_respond_to @class, :apotomo_request_processor
+    end
+    
+    should "mixin all methods after first use of .has_widgets" do
+      @class.has_widgets do |root|
+      end
+      
+      assert_respond_to @class, :has_widgets
+      assert_respond_to @controller, :apotomo_request_processor
     end
   end
 end