apotomo 0.1.1

data/app/cells/apotomo/child_switch_widget/switch.html.erb

@@ -0,0 +1 @@
+<%= @content.to_s %>

data/app/cells/apotomo/child_switch_widget/switch.rhtml

@@ -0,0 +1 @@
+<%= @content.to_s %>

data/app/cells/apotomo/deep_link_widget.rb

@@ -0,0 +1,27 @@
+class Apotomo::DeepLinkWidget < Apotomo::StatefulWidget
+  
+  transition :from => :setup, :to => :process
+  transition :in   => :process
+  
+  def setup
+    root.respond_to_event :externalChange, :on => 'deep_link', :with => :process
+    root.respond_to_event :internalChange, :on => 'deep_link', :with => :process
+    
+    render
+  end
+  
+  def process
+    # find out what changed in the deep link
+      # find the update root (### DISCUSS: this might be more than one root, as in A--B)
+    #path = param(:deep_link)  # path is #tab=users/icon=3
+    
+    update_root = root.find {|w| w.responds_to_url_change? and w.responds_to_url_change_for?(url_fragment)}  ### DISCUSS: we just look for one root here.
+    
+    if update_root
+      controller.logger.debug "deep_link#process: `#{update_root.name}` responds to :urlChange"
+      update_root.trigger(:urlChange)
+    end
+    
+    render :nothing => true
+  end
+end

data/app/cells/apotomo/deep_link_widget/setup.html.erb

@@ -0,0 +1,20 @@
+<%= javascript_tag "
+   	SWFAddress.onInternalChange = function() {
+   		//alert('internalChange');
+   		#{remote_function :url => address_to_event(:type=>:internalChange),  :with => '\'deep_link=\'+SWFAddress.getPath()'}
+   	}
+   	
+   	SWFAddress.onExternalChange = function() {
+   		//alert(SWFAddress.getPath()+SWFAddress.getQueryString());
+   		#{remote_function :url => address_to_event(:type=>:internalChange),  :with => '\'deep_link=\'+SWFAddress.getPath()'}
+   	}
+   	
+   	
+    	SWFAddress.onChange = function() {
+   		}
+   		
+   		SWFAddress.onInit = function() {
+   		#{remote_function :url => address_to_event(:type=>:internalChange),  :with => '\'deep_link=\'+SWFAddress.getPath()'}
+   			//alert('init');
+   		}
+   		" %>

data/app/cells/apotomo/java_script_widget.rb

@@ -0,0 +1,12 @@
+module Apotomo
+  
+  ### TODO: if a state doesn't return anything, the view-finding is invoked, which
+  ###   is nonsense in a JS widget. current work-around: return render :js => ""
+  
+  class JavaScriptWidget < StatefulWidget
+    def frame_content(content)
+      content
+    end
+  end
+  
+end

data/app/cells/apotomo/tab_panel_widget.rb

@@ -0,0 +1,87 @@
+module Apotomo
+  class TabPanelWidget < StatefulWidget
+    transition :from => :display, :to => :switch
+    transition                    :in => :switch
+    
+    attr_accessor :current_child_id
+    
+    
+    # Called in StatefulWidget's constructor.
+    def initialize_deep_link_for(id, start_states, opts)
+      return unless opts[:is_url_listener]
+      
+      respond_to_event :urlChange, :from => self.name, :with => :switch
+    end
+    
+    
+    
+    def display
+      respond_to_event(:switchChild, :with => :switch)
+      
+      
+      @current_child_id  = find_current_child.name
+      
+      render :locals => {:tabs => children}
+    end
+    
+    
+    def switch
+      @current_child_id  = find_current_child.name
+      
+      render :view => :display, :locals => {:tabs => children}
+    end
+    
+    
+    def children_to_render
+      [children.find{ |c| c.name == @current_child_id } ]
+    end
+    
+    ### DISCUSS: use #find_param instead of #param to provide a cleaner parameter retrieval?
+    def find_current_child
+      if responds_to_url_change?
+        child_id  = url_fragment[param_name]
+      else
+        child_id  = param(param_name)
+      end
+      
+      find_child(child_id) || find_child(@current_child_id) || default_child
+    end
+    
+    def default_child;  children.first;   end
+    
+    
+    def find_child(id)
+      children.find { |c| c.name.to_s == id }
+    end
+    
+    def param_name; name; end
+    
+    
+    # Called by deep_link_widget#process to query if we're involved in an URL change.
+    def responds_to_url_change_for?(fragment)
+      # don't respond to an empty/invalid/ fragment as we don't get any information from it:
+      return if fragment[param_name].blank?
+      
+      fragment[param_name] != @current_child_id
+    end
+    
+    def local_fragment
+      "#{param_name}=#{current_child_id}"
+    end
+    
+    
+    # Used in view to create the tab link in deep-linking mode.
+    def url_fragment_for_tab(tab)
+      url_fragment_for("#{param_name}=#{tab.name}")
+    end
+    
+    
+    def address(way={}, target=self, state=nil)
+      way.merge!( local_address(target, way, state) )
+
+      return way if isRoot?
+
+      return parent.address(way, target)
+    end
+  end
+end

data/app/cells/apotomo/tab_panel_widget/display.html.erb

@@ -0,0 +1,57 @@
+<style type="text/css">
+  .TabPanel ul {
+    display: block;
+    list-style: none;
+    padding: 0;
+    margin: 0 0 -1px 0;
+    height: 100%;
+    font-size: 14px;
+    border-left: 1px solid #888888;
+
+  }
+
+  .TabPanel ul li {
+    float: left;
+    margin: 0;
+    padding: 5px;
+    background-color: #dbdbdb;
+    color: #888888;
+    border-top: 1px solid #888888;
+    border-right: 1px solid #888888;
+    border-bottom: 1px solid #888888;
+  }
+
+  .TabPanel ul li.active {
+    border-bottom: 1px solid #ffffff;
+    background-color: #ffffff;
+    color: #000000;
+
+  }
+
+  .TabPanel ul li a, .TabPanel ul li a:visited {
+    color: #888888
+  }
+</style>
+
+
+<div class="TabPanel">
+  <ul>
+    <% tabs.each do |tab|
+  	  tab_class = ""   
+	  tab_class = "active" if tab.name == @current_child_id
+    %>
+    <li class="<%= tab_class %>">
+      <%- if @cell.responds_to_url_change? %>
+      	<%= link_to_function tab.title, update_url(@cell.url_fragment_for_tab(tab)) %>
+      <%- else %>
+		<%= link_to_event tab.title, {:type => :switchChild, @cell.param_name => tab.name} %>
+      <% end %>
+    </li>
+    <% end -%>
+    
+    <div style="clear: both;" />
+  </ul>
+</div>
+<div style="clear: both;"></div>
+
+<%= rendered_children.first %>

data/app/cells/apotomo/tab_widget.rb

@@ -0,0 +1,18 @@
+module Apotomo
+  class TabWidget < StatefulWidget
+    
+    attr_accessor :title
+    
+    def initialize(*args)
+      super(*args)
+      
+      @title = @opts[:title] || self.name.to_s
+    end
+    
+    
+    def display
+      render
+    end
+    
+  end
+end

data/app/cells/apotomo/tab_widget/display.html.erb

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

data/config/routes.rb

@@ -0,0 +1,3 @@
+ActionController::Routing::Routes.draw do |map|
+  map.apotomo_event ':controller/render_event_response', :action => 'render_event_response'
+end

data/generators/widget/USAGE

@@ -0,0 +1,15 @@
+Description:
+	Stubs out a new cell widget, its state views and a functional test.
+  Pass the cell name, either CamelCased or under_scored, and a list 
+  of states as arguments.
+	
+	This generates a cell class in app/cells and view templates in
+	app/cells/cell_name.
+
+Example:
+	'./script/generate widget Posting new'
+	
+	This will create an Apotomo Posting cell:
+		Cell: app/cells/posting_cell.rb
+		Views: app/cells/posting/new.html.erb
+    Test: test/functional/test_posting_cell.rb

data/generators/widget/templates/functional_test.rb

@@ -0,0 +1,8 @@
+require "test_helper"
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  test "a first test" do
+    html = widget(:<%= file_name %>, :<%= states.first %>, 'my_<%= file_name %>').invoke
+    assert_selekt html, "p"
+  end
+end

data/generators/widget/templates/view.html.erb

@@ -0,0 +1,2 @@
+<h1><%= class_name %>#<%= action %></h1>
+<p>Find me in <%= path %></p>

data/generators/widget/templates/view.html.haml

@@ -0,0 +1,3 @@
+%h1 "<%= class_name %>#<%= action %>"
+%p
+  Find me in <%= path %>

data/generators/widget/templates/widget.rb

@@ -0,0 +1,8 @@
+class <%= class_name %> < Apotomo::Widget
+<% for action in actions -%>
+  def <%= action %>
+    render
+  end
+  
+<% end -%>
+end

data/generators/widget/widget_generator.rb

@@ -0,0 +1,34 @@
+require 'rails_generator/generators/components/controller/controller_generator'
+
+class WidgetGenerator < ControllerGenerator
+  def add_options!(opt)
+    opt.on('--haml') { |value| options[:view_format] = 'haml' }
+  end
+  
+  def manifest
+    options.reverse_merge! :view_format => 'erb'
+    
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, "#{class_name}"
+
+      # Directories
+      m.directory File.join('app/cells', class_path)
+      m.directory File.join('app/cells', class_path, file_name)
+      m.directory File.join('test/widgets')
+      
+      # Widget
+      m.template 'widget.rb', File.join('app/cells', class_path, "#{file_name}.rb")
+      
+      # View template for each state.
+      format = options[:view_format]
+      actions.each do |state|
+        path = File.join('app/cells', class_path, file_name, "#{state}.html.#{format}")
+        m.template "view.html.#{format}", path, :assigns => { :action => state, :path => path }
+      end
+      
+      # Functional test for the widget.
+      m.template 'functional_test.rb', File.join('test/widgets/', "#{file_name}_test.rb"), :assigns => {:states => actions}
+    end
+  end
+end

data/lib/apotomo.rb

@@ -0,0 +1,59 @@
+#  Copyright (c) 2007-2010 Nick Sutterer <apotonick@gmail.com>
+#  
+#  The MIT License
+#  
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to deal
+#  in the Software without restriction, including without limitation the rights
+#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#  copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+#  
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#  
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#  THE SOFTWARE.
+#  
+
+
+require 'cells'
+require 'onfire'
+
+module Apotomo
+  class << self
+    def js_framework=(js_framework)
+      @js_framework = js_framework
+      @js_generator = ::Apotomo::JavascriptGenerator.new(js_framework)
+    end
+    
+    attr_reader :js_generator, :js_framework
+    
+    # Apotomo setup/configuration helper for initializer.
+    #
+    # == Usage/Examples:
+    #
+    #   Apotomo.setup do |config|
+    #     config.js_framework = :jquery
+    #   end
+    def setup
+      yield self
+    end
+  end
+end
+
+### FIXME: move to rails.rb
+
+require 'apotomo/javascript_generator'
+Apotomo.js_framework = :prototype ### DISCUSS: move to rails.rb
+
+### DISCUSS: move to 'apotomo/widgets'?
+require 'apotomo/widget'
+require 'apotomo/stateful_widget'
+require 'apotomo/container_widget'
+require 'apotomo/widget_shortcuts'

data/lib/apotomo/caching.rb

@@ -0,0 +1,37 @@
+# Introduces caching of rendered state views into the StatefulWidget.
+module Apotomo::Caching
+    
+  def self.included(base) #:nodoc:
+    base.class_eval do
+      extend ClassMethods
+    end
+  end
+
+
+  module ClassMethods
+    # If <tt>version_proc</tt> is omitted, Apotomo provides some basic caching 
+    # mechanism: the state view rendered for <tt>state</tt> will be cached as long
+    # as you (or e.g. an EventHandler) calls #dirty!. It will then be re-rendered
+    # and cached again.
+    # You may override that to provide fine-grained caching, with multiple cache versions
+    # for the same state.
+    def cache(state, version_proc=:cache_version)
+      super(state, version_proc)
+    end
+  end
+  
+  def cache_version
+    @version ||= 0
+    {:v => @version}
+  end
+  
+  def increment_version
+    @version += 1
+  end
+  
+  # Instruct caching to re-render all cached state views.
+  def dirty!
+    increment_version
+  end
+  
+end

data/lib/apotomo/container_widget.rb

@@ -0,0 +1,10 @@
+require 'apotomo/widget'
+
+module Apotomo
+  class ContainerWidget < Widget
+    def display
+      content = render_children.collect{ |v| v.last }.join("\n")
+      render :text => "<div id=\"#{self.name}\">#{content}</div>"
+    end
+  end
+end

data/lib/apotomo/deep_link_methods.rb

@@ -0,0 +1,90 @@
+module Apotomo
+  module DeepLinkMethods
+    def self.included(base)
+      base.initialize_hooks << :initialize_deep_link_for
+    end
+    
+    
+    # Called in StatefulWidget's constructor.
+    def initialize_deep_link_for(id, start_states, opts)
+      #add_deep_link if opts[:is_url_listener] ### DISCUSS: remove #add_de
+    end
+    
+    def responds_to_url_change?
+      evt_table.all_handlers_for(:urlChange, name).size > 0
+    end
+    
+    
+    ### DISCUSS: private? rename to compute_url_fragment_for ?
+    # Computes the fragment part of the widget's url by querying all widgets up to root.
+    # Widgets managing a certain state will usually insert state recovery information
+    # via local_fragment.
+    def url_fragment_for(local_portion=nil, portions=[])
+      local_portion = local_fragment if responds_to_url_change? and local_portion.nil?
+      
+      portions.unshift(local_portion) # prepend portions as we move up.
+      
+      return portions.compact.join("/") if root?
+      
+      parent.url_fragment_for(nil, portions)
+    end
+    
+    
+    # Called when widget :is_url_listener. Adds the local url fragment portion to the url.
+    def local_fragment
+      #"#{local_fragment_key}=#{state_name}"
+    end
+    
+    # Key found in the url fragment, pointing to the local fragment.
+    #def local_fragment_key
+    #  name
+    #end
+    
+    
+    # Called by DeepLinkWidget#process to query if we're involved in an URL change.
+    # Do return false if you're not interested in the change.
+    #
+    # This especially means:
+    #  * the fragment doesn't include you or is empty
+    #   fragment[name].blank?
+    #  * your portion in the fragment didn't change
+    #   tab=first/content=html vs. tab=first/content=markdown
+    #   fragment[:tab] != @active_tab
+    def responds_to_url_change_for?(fragment)
+    end
+    
+    
+    
+    class UrlFragment
+      attr_reader :fragment
+      
+      def initialize(fragment)
+        @fragment = fragment || ""
+      end
+      
+      def to_s
+        fragment.to_s
+      end
+      
+      def blank?
+        fragment.blank?
+      end
+      
+      ### TODO: make path separator configurable.
+      def [](key)
+        if path_portion = fragment.split("/").find {|i| i.include?(key.to_s)}
+          return path_portion.sub("#{key}=", "")
+        end
+        
+        nil
+      end
+    end
+    
+    # Query object for the url fragment. Use this to retrieve state information from the
+    # deep link.
+    def url_fragment
+      UrlFragment.new(param(:deep_link))
+    end
+    
+  end
+end