apotomo 1.0.5 → 1.1.0.rc1

data/test/dummy/public/javascripts/rails.js

@@ -1,175 +0,0 @@
-(function() {
-  // Technique from Juriy Zaytsev
-  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
-  function isEventSupported(eventName) {
-    var el = document.createElement('div');
-    eventName = 'on' + eventName;
-    var isSupported = (eventName in el);
-    if (!isSupported) {
-      el.setAttribute(eventName, 'return;');
-      isSupported = typeof el[eventName] == 'function';
-    }
-    el = null;
-    return isSupported;
-  }
-
-  function isForm(element) {
-    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
-  }
-
-  function isInput(element) {
-    if (Object.isElement(element)) {
-      var name = element.nodeName.toUpperCase()
-      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
-    }
-    else return false
-  }
-
-  var submitBubbles = isEventSupported('submit'),
-      changeBubbles = isEventSupported('change')
-
-  if (!submitBubbles || !changeBubbles) {
-    // augment the Event.Handler class to observe custom events when needed
-    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
-      function(init, element, eventName, selector, callback) {
-        init(element, eventName, selector, callback)
-        // is the handler being attached to an element that doesn't support this event?
-        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
-             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
-          // "submit" => "emulated:submit"
-          this.eventName = 'emulated:' + this.eventName
-        }
-      }
-    )
-  }
-
-  if (!submitBubbles) {
-    // discover forms on the page by observing focus events which always bubble
-    document.on('focusin', 'form', function(focusEvent, form) {
-      // special handler for the real "submit" event (one-time operation)
-      if (!form.retrieve('emulated:submit')) {
-        form.on('submit', function(submitEvent) {
-          var emulated = form.fire('emulated:submit', submitEvent, true)
-          // if custom event received preventDefault, cancel the real one too
-          if (emulated.returnValue === false) submitEvent.preventDefault()
-        })
-        form.store('emulated:submit', true)
-      }
-    })
-  }
-
-  if (!changeBubbles) {
-    // discover form inputs on the page
-    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
-      // special handler for real "change" events
-      if (!input.retrieve('emulated:change')) {
-        input.on('change', function(changeEvent) {
-          input.fire('emulated:change', changeEvent, true)
-        })
-        input.store('emulated:change', true)
-      }
-    })
-  }
-
-  function handleRemote(element) {
-    var method, url, params;
-
-    var event = element.fire("ajax:before");
-    if (event.stopped) return false;
-
-    if (element.tagName.toLowerCase() === 'form') {
-      method = element.readAttribute('method') || 'post';
-      url    = element.readAttribute('action');
-      params = element.serialize();
-    } else {
-      method = element.readAttribute('data-method') || 'get';
-      url    = element.readAttribute('href');
-      params = {};
-    }
-
-    new Ajax.Request(url, {
-      method: method,
-      parameters: params,
-      evalScripts: true,
-
-      onComplete:    function(request) { element.fire("ajax:complete", request); },
-      onSuccess:     function(request) { element.fire("ajax:success",  request); },
-      onFailure:     function(request) { element.fire("ajax:failure",  request); }
-    });
-
-    element.fire("ajax:after");
-  }
-
-  function handleMethod(element) {
-    var method = element.readAttribute('data-method'),
-        url = element.readAttribute('href'),
-        csrf_param = $$('meta[name=csrf-param]')[0],
-        csrf_token = $$('meta[name=csrf-token]')[0];
-
-    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
-    element.parentNode.insert(form);
-
-    if (method !== 'post') {
-      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
-      form.insert(field);
-    }
-
-    if (csrf_param) {
-      var param = csrf_param.readAttribute('content'),
-          token = csrf_token.readAttribute('content'),
-          field = new Element('input', { type: 'hidden', name: param, value: token });
-      form.insert(field);
-    }
-
-    form.submit();
-  }
-
-
-  document.on("click", "*[data-confirm]", function(event, element) {
-    var message = element.readAttribute('data-confirm');
-    if (!confirm(message)) event.stop();
-  });
-
-  document.on("click", "a[data-remote]", function(event, element) {
-    if (event.stopped) return;
-    handleRemote(element);
-    event.stop();
-  });
-
-  document.on("click", "a[data-method]", function(event, element) {
-    if (event.stopped) return;
-    handleMethod(element);
-    event.stop();
-  });
-
-  document.on("submit", function(event) {
-    var element = event.findElement(),
-        message = element.readAttribute('data-confirm');
-    if (message && !confirm(message)) {
-      event.stop();
-      return false;
-    }
-
-    var inputs = element.select("input[type=submit][data-disable-with]");
-    inputs.each(function(input) {
-      input.disabled = true;
-      input.writeAttribute('data-original-value', input.value);
-      input.value = input.readAttribute('data-disable-with');
-    });
-
-    var element = event.findElement("form[data-remote]");
-    if (element) {
-      handleRemote(element);
-      event.stop();
-    }
-  });
-
-  document.on("ajax:after", "form", function(event, element) {
-    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
-    inputs.each(function(input) {
-      input.value = input.readAttribute('data-original-value');
-      input.removeAttribute('data-original-value');
-      input.disabled = false;
-    });
-  });
-})();

data/test/dummy/script/rails

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
-
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
-require 'rails/commands'

data/test/dummy/tmp/app/cells/mouse_widget.rb

@@ -1,11 +0,0 @@
-class MouseWidget < Apotomo::Widget
-
-  def squeak
-    render
-  end
-
-  def snuggle
-    render
-  end
-
-end

data/test/dummy/tmp/app/cells/mouse_widget/snuggle.html.erb

@@ -1,7 +0,0 @@
-<h1>
-  MouseWidget#snuggle
-</h1>
-
-<p>
-  Find me in app/cells/mouse_widget/snuggle.html.erb
-</p>

data/test/dummy/tmp/app/cells/mouse_widget/squeak.html.erb

@@ -1,7 +0,0 @@
-<h1>
-  MouseWidget#squeak
-</h1>
-
-<p>
-  Find me in app/cells/mouse_widget/squeak.html.erb
-</p>

data/test/dummy/tmp/test/widgets/mouse_widget_test.rb

@@ -1,12 +0,0 @@
-require 'test_helper'
-
-class MouseWidgetTest < Apotomo::TestCase
-  has_widgets do |root|
-    root << widget(:mouse_widget, 'me')
-  end
-  
-  test "display" do
-    render_widget 'me'
-    assert_select "h1"
-  end
-end

data/test/fixtures/application_widget_tree.rb

@@ -1,2 +0,0 @@
-class ApplicationWidgetTree < Apotomo::WidgetTree
-end

data/test/fixtures/mouse/snuggle.html.erb

@@ -1 +0,0 @@
-<div id="<%= @name %>"><snuggle><%= rendered_children.collect{|e| e.last}.join("").html_safe %></snuggle></div>

data/test/rails/view_methods_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-class ViewMethodsTest < ActionController::TestCase
-  include Apotomo::TestCaseMethods::TestController
-  
-  context "A Rails controller view" do
-    setup do
-      @controller.instance_variable_set(:@mum, mouse_mock('mum', 'snuggle') {def snuggle; render; end})
-      @controller.instance_eval do
-        def widget
-          use_widgets do |root|
-            root << @mum
-          end
-          render :inline => "<%= render_widget 'mum' %>"
-        end
-      end
-    end
-    
-    should "respond to render_widget" do
-      get :widget
-      assert_select "#mum>snuggle"
-    end
-    
-    should "respond to url_for_event" do
-      @controller.instance_eval do
-        def widget
-          use_widgets do |root|
-            root << @mum
-          end
-          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

data/test/unit/container_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-
-class ContainerTest < Test::Unit::TestCase
-  include Apotomo::TestCaseMethods::TestController
-  
-  context "Rendering a container" do
-    setup do
-      @family = container('family')
-    end
-    
-    should "return an empty view if childless" do
-      assert_equal "<div id=\"family\"></div>", @family.invoke
-    end
-    
-    should "provide a family picture" do
-      @family << mouse_mock('mum')
-      @family << mouse_mock('kid')
-      assert_equal "<div id=\"family\"><div id=\"mum\">burp!</div>\n<div id=\"kid\">burp!</div></div>", @family.invoke
-    end
-  end
-end

data/test/unit/invoke_test.rb

@@ -1,126 +0,0 @@
-require 'test_helper'
-
-class InvokeTest < Test::Unit::TestCase
-  include Apotomo::TestCaseMethods::TestController
-  
-  class LocalMouse < MouseCell
-    def snuggle; render; end
-    def educate; render :view => :snuggle; end
-  end
-  
-  context "Invoking a single widget" do
-    setup do
-      @mum = LocalMouse.new(parent_controller, 'mum', :snuggle)
-    end
-    
-    context "implicitely" do
-      should "always enter the given state" do
-        @mum.invoke :snuggle
-        assert_equal 'snuggle', @mum.last_state
-        
-        @mum.invoke :educate
-        assert_equal 'educate', @mum.last_state
-      end
-    end
-    
-    context "explicitely" do
-      should "per default enter the start state" do
-        @mum.invoke
-        assert_equal 'snuggle', @mum.last_state
-        
-        @mum.invoke
-        assert_equal 'snuggle', @mum.last_state
-      end
-      
-      context "with defined transitions" do
-        setup do
-          @mum.instance_eval do
-            self.class.transition :from => :snuggle, :to => :educate
-          end
-          
-          @mum.invoke
-          assert_equal 'snuggle', @mum.last_state
-        end
-        
-        should "automatically follow the transitions if defined" do
-          assert_equal 'snuggle', @mum.last_state
-          @mum.invoke
-          assert_equal 'educate', @mum.last_state
-        end
-        
-        should "nevertheless allow undefined implicit invokes" do
-          @mum.invoke :snuggle
-          assert_equal 'snuggle', @mum.last_state
-        end
-      end
-    end
-  end
-  
-  context "Invoking a widget family" do
-    setup do
-      @mum = LocalMouse.new(parent_controller, 'mum', :snuggle)
-      
-      # create an anonym class for @kid so we don't pollute with #transition's.
-      @mum << @kid = mouse_class_mock.new(parent_controller, 'kid', :snooze)
-      @kid.instance_eval do
-        def snooze; render :nothing => true; end
-        def listen; render :nothing => true; end
-      end
-    end
-    
-    context "implicitely" do
-      should "per default send kid to its start state" do
-        @mum.invoke :snuggle
-        assert_equal 'snuggle',  @mum.last_state
-        assert_equal 'snooze',   @kid.last_state
-        
-        @mum.invoke :educate
-        assert_equal 'educate',  @mum.last_state
-        assert_equal 'snooze',   @kid.last_state
-      end
-      
-      should "follow the kid's transition if defined" do
-        @kid.instance_eval do
-          self.class.transition :from => :snooze, :to => :listen
-        end
-        
-        @mum.invoke :snuggle
-        @mum.invoke :educate
-        assert_equal 'educate',  @mum.last_state
-        assert_equal 'listen',   @kid.last_state
-      end
-      
-      should "send kid to the given state passed to #render" do
-        @mum.instance_eval do
-          def snuggle
-            render :invoke => {'kid' => :listen}
-          end
-        end
-        
-        @mum.invoke :snuggle
-        assert_equal 'snuggle',  @mum.last_state
-        assert_equal 'listen',   @kid.last_state
-      end
-      
-      should "send kid to the :invoke state as it overrides #transition" do
-        @kid.instance_eval do
-          self.class.transition :from => :snooze, :to => :listen
-        end
-        
-        @mum.instance_eval do
-          def educate
-            render :nothing => true, :invoke => {'kid' => :snooze}
-          end
-        end
-        
-        @mum.invoke :snuggle
-        assert_equal 'snuggle',  @mum.last_state
-        assert_equal 'snooze',   @kid.last_state
-        
-        @mum.invoke :educate
-        assert_equal 'educate',  @mum.last_state
-        assert_equal 'snooze',   @kid.last_state
-      end
-    end
-  end
-end

data/test/unit/persistence_test.rb

@@ -1,201 +0,0 @@
-require 'test_helper'
-
-class PersistenceTest < Test::Unit::TestCase
-  include Apotomo::TestCaseMethods::TestController
-  
-  class PersistentMouse < Apotomo::StatefulWidget # we need a named class for marshalling.
-    attr_reader :who, :what
-      
-    def educate
-      @who  = "the cat"
-      @what = "run away"
-      render :nothing => true
-    end
-      
-    def recap;  render :nothing => true; end
-  end
-  
-  def stateless(name)
-    Apotomo::Widget.new(parent_controller, name, :eat)
-  end
-  
-  def stateful(name)
-    PersistentMouse.new(parent_controller, name, :educate)
-  end
-  
-  context "StatefulWidget" do
-  
-    context ".stateful_branches_for" do
-      should "provide all stateful branch-roots seen from root" do
-        @root = stateless('root')
-        @root << mum_and_kid!
-        @root << stateless('berry') << @jerry = mouse_mock('jerry', :eat)
-        
-        assert_equal ['mum', 'jerry'], Apotomo::StatefulWidget.stateful_branches_for(@root).collect {|n| n.name}
-      end
-    end
-  end
-  
-  context "freezing and thawing a widget family" do
-    setup do
-      mum_and_kid!
-      @storage = {}
-    end
-    
-    context "and calling #flush_storage" do
-      should "clear the storage from frozen data" do
-        @root = stateless('root')
-        @root << @mum
-          
-        Apotomo::StatefulWidget.freeze_for(@storage, @root)
-        
-        assert @storage[:apotomo_stateful_branches]
-        assert @storage[:apotomo_widget_ivars]
-        
-        Apotomo::StatefulWidget.flush_storage(@storage)
-        
-        assert_nil @storage[:apotomo_stateful_branches]
-        assert_nil @storage[:apotomo_widget_ivars]
-      end
-    end
-    
-    should "push @mum's freezable ivars to the storage when calling #freeze_ivars_to" do
-      @mum.freeze_ivars_to(@storage)
-      
-      assert_equal 1, @storage.size
-      assert_equal 6, @storage['mum'].size
-    end
-    
-    should "push family's freezable ivars to the storage when calling #freeze_data_to" do
-      @kid << mouse_mock('pet')
-      @mum.freeze_data_to(@storage)
-      
-      assert_equal 3, @storage.size
-      assert_equal 6, @storage['mum'].size
-      assert_equal 6, @storage['mum/kid'].size
-      assert_equal 5, @storage['mum/kid/pet'].size
-    end
-    
-    should "push ivars and structure to the storage when calling #freeze_to" do
-      @mum.freeze_to(@storage)
-      assert_equal 2, @storage[:apotomo_widget_ivars].size
-      assert_kind_of Apotomo::StatefulWidget, @storage[:apotomo_root]
-    end
-    
-    context "that has also stateless widgets" do
-      setup do
-        @root = stateless('root')
-          @root << mum_and_kid!
-          @root << stateless('berry') << @jerry = mouse_mock('jerry', :eat)
-        @root << stateless('tom')
-        
-        Apotomo::StatefulWidget.freeze_for(@storage, @root)
-      end
-      
-      should "ignore stateless widgets when calling #freeze_for" do
-        assert_equal(['root/mum', 'root/mum/kid', "root/berry/jerry"], @storage[:apotomo_widget_ivars].keys)
-      end
-      
-      should "save stateful branches only" do
-        assert_equal([[[MouseCell, 'mum', 'root'], [MouseCell, 'kid', 'mum']], [[MouseCell, 'jerry', 'berry']]], @storage[:apotomo_stateful_branches])
-      end
-      
-      should "attach stateful branches to the tree in thaw_for" do
-        @new_root = stateless('root')
-          @new_root << stateless('berry')
-        assert_equal @new_root, Apotomo::StatefulWidget.thaw_for(@controller, @storage, @new_root)
-        
-        assert_equal 5, @new_root.size  # without tom.
-      end
-      
-      should "re-establish ivars recursivly when calling #thaw_for" do
-        @storage[:apotomo_stateful_branches] = Marshal.load(Marshal.dump(@storage[:apotomo_stateful_branches]))
-        
-        @new_root = stateless('root')
-          @new_root << stateless('berry')
-        @new_root = Apotomo::StatefulWidget.thaw_for(@controller, @storage, @new_root)
-        
-        assert_equal :answer_squeak,  @new_root['mum'].instance_variable_get(:@start_state)
-        assert_equal :peek,           @new_root['mum']['kid'].instance_variable_get(:@start_state)
-      end
-      
-      should "raise an exception when thaw_for can't find the branch's parent" do
-        @new_root = stateless('dad')
-        
-        assert_raises RuntimeError do
-           Apotomo::StatefulWidget.thaw_for(@controller, @storage, @new_root)
-        end
-      end
-      
-      should "clear the fields in the storage when fetching in #thaw_for" do
-        @new_root = stateless('root')
-          @new_root << stateless('berry')
-        
-        Apotomo::StatefulWidget.thaw_for(@controller, @storage, @new_root)
-        
-        assert_nil @storage[:apotomo_stateful_branches]
-        assert_nil @storage[:apotomo_widget_ivars]
-      end
-    end
-    
-    should "update @mum's ivars when calling #thaw_ivars_from" do
-      @mum.instance_variable_set(:@name, "zombie mum")
-      assert_equal 'zombie mum', @mum.name
-      
-      @mum.thaw_ivars_from({'zombie mum' => {'@name' => 'mum'}})
-      assert_equal 'mum', @mum.name
-    end
-    
-    should "update family's ivars when calling #thaw_data_from" do
-      @kid << @pet = mouse_mock('pet')
-      @kid.instance_variable_set(:@name, "paranoid kid")
-      @pet.instance_variable_set(:@name, "mad dog")
-      assert_equal "paranoid kid", @kid.name
-      
-      @mum.thaw_data_from({ "mum/paranoid kid"  => {'@name' => 'kid'},
-                            "mum/kid/mad dog"   => {'@name' => 'pet'}})
-      assert_equal 'kid', @kid.name
-      assert_equal 'pet', @pet.name
-    end
-    
-    
-  end
-  
-  context "#dump_tree" do
-    setup do
-      @mum = stateful('mum')
-      @mum << @kid = stateful('kid')
-        @kid << @pet = stateful('pet')
-      @mum << @berry = stateful('berry')
-      
-    end
-    
-    should "return a list of widget metadata" do
-      assert_equal [[PersistentMouse, 'mum', nil], [PersistentMouse, 'kid', 'mum'], [PersistentMouse, 'pet', 'kid'], [PersistentMouse, 'berry', 'mum']], @mum.dump_tree
-    end
-    
-    should "return a tree for #load_tree" do
-      cold_widgets = @mum.dump_tree
-      assert_equal ['mum', 'kid', 'pet', 'berry'], Apotomo::StatefulWidget.send(:load_tree, @controller, cold_widgets).collect { |n| n.name }
-    end
-    
-    context "#frozen_widget_in?" do
-      should "return true if a valid widget is passed" do
-        @session = {}
-        assert_not Apotomo::StatefulWidget.frozen_widget_in?(@session)
-        Apotomo::StatefulWidget.freeze_for(@session, @berry)
-        assert Apotomo::StatefulWidget.frozen_widget_in?(@session)
-      end
-    end
-  end
-  
-  
-  
-  context "#symbolized_instance_variables?" do
-    should "return instance_variables as symbols" do
-      @mum = mouse_mock
-      assert_equal @mum.instance_variables.size, @mum.symbolized_instance_variables.size
-      assert_not @mum.symbolized_instance_variables.find { |ivar| ivar.kind_of? String }
-    end
-  end
-end