wee 0.8.0 → 0.9.0

data/lib/wee/application.rb

@@ -57,26 +57,9 @@ class Wee::Application
       # No id was given -> check whether the maximum number of request-handlers
       # limit is reached. if not, create new id and handler
 
-      @mutex.synchronize {
-        if @max_request_handlers != nil and @request_handlers.size >= @max_request_handlers
-          # limit reached -> remove non-alive handlers...
-          garbage_collect_handlers()
-
-          # ...and test again
-          if @request_handlers.size >= @max_request_handlers
-            # TODO: show a custom error message
-            raise "maximum number of request-handlers reached" 
-          end
-        end
-
-        request_handler_id =  unique_request_handler_id()
-        request_handler = @default_request_handler.call  
-        request_handler.id = request_handler_id
-        request_handler.application = self
-        @request_handlers[request_handler_id] = request_handler
-      }
-
-      context.request.request_handler_id = request_handler_id 
+      request_handler = @default_request_handler.call 
+      insert_new_request_handler(request_handler)
+      context.request.request_handler_id = request_handler.id 
       handle_request(context)
       return
 
@@ -103,6 +86,25 @@ class Wee::Application
     context.response = Wee::ErrorResponse.new(exn) 
   end
 
+  def insert_new_request_handler(request_handler)
+    @mutex.synchronize {
+      if @max_request_handlers != nil and @request_handlers.size >= @max_request_handlers
+        # limit reached -> remove non-alive handlers...
+        garbage_collect_handlers()
+
+        # ...and test again
+        if @request_handlers.size >= @max_request_handlers
+          # TODO: show a custom error message
+          raise "maximum number of request-handlers reached" 
+        end
+      end
+
+      request_handler.id = unique_request_handler_id()
+      request_handler.application = self
+      @request_handlers[request_handler.id] = request_handler
+    }
+  end
+
   # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   # :section: Properties
   # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

data/lib/wee/components.rb

@@ -2,3 +2,6 @@ require 'wee/components/wrapper_decoration'
 require 'wee/components/form_decoration'
 require 'wee/components/page_decoration'
 require 'wee/components/messagebox'
+require 'wee/components/component_dispatcher'
+require 'wee/components/login_decoration'
+require 'wee/components/pager'

data/lib/wee/components/component_dispatcher.rb

@@ -0,0 +1,46 @@
+require 'set'
+
+class Wee::ComponentDispatcher < Wee::Component
+  def initialize
+    super()
+    @rules = []
+    @components = Set.new
+  end
+
+  def add_rule(pattern, component, &block)
+    @components.add(component)
+    @rules << [pattern, component, block]
+  end
+
+  def do_render(rendering_context)
+    if component = match(session.current_context.request.info)
+      component.do_render_chain(rendering_context)
+    end
+  end
+
+  def process_callbacks(&block)
+    if component = match(session.current_context.request.info)
+      component.process_callbacks_chain(&block)
+    end
+  end
+
+  def backtrack_state(snapshot)
+    snapshot.add(@__decoration)
+    @components.each do |component|
+      component.backtrack_state_chain(snapshot)
+    end
+  end
+
+  protected
+
+  def match(info)
+    info ||= ""
+    @rules.each do |pattern, component, block|
+      if info =~ pattern
+        block.call(component, $~) if block 
+        return component 
+      end
+    end
+    nil
+  end
+end

data/lib/wee/components/login_decoration.rb

@@ -0,0 +1,35 @@
+class Wee::LoginDecoration < Wee::Decoration
+  def initialize(login_page)
+    @login_page = login_page
+  end
+
+  def process_callbacks(&block)
+    if logged_in?
+      super
+    else
+      @login_page.process_callbacks_chain(&block)
+    end
+  end
+
+  def do_render(rendering_context)
+    if logged_in?
+      super
+    else
+      @login_page.do_render_chain(rendering_context)
+    end
+  end
+
+  def backtrack_state(snapshot)
+    if logged_in?
+      super
+    else
+      @login_page.backtrack_state_chain(snapshot)
+    end
+  end
+
+  # Overwrite this method!
+
+  def logged_in?
+    raise "subclass responsibility"
+  end
+end

data/lib/wee/components/messagebox.rb

@@ -7,9 +7,9 @@ class Wee::MessageBox < Wee::Component
   def render
     r.bold(@text)
     r.form do 
-      r.submit_button.value('OK').callback { answer true }
+      r.submit_button.value('OK').callback(:answer, true)
       r.space
-      r.submit_button.value('Cancel').callback { answer false }
+      r.submit_button.value('Cancel').callback(:answer, false)
     end
   end
 end

data/lib/wee/components/pager.rb

@@ -0,0 +1,102 @@
+class Wee::Pager < Wee::Component
+  attr_accessor :num_entries, :entries_per_page
+  attr_reader :current_page
+
+  def initialize(num_entries=0)
+    super()
+    @num_entries = num_entries
+    @current_page = 0
+    @entries_per_page = 20
+    yield self if block_given?
+  end
+
+  # Returns the number of pages
+
+  def num_pages
+    n, rest = @num_entries.divmod(@entries_per_page)
+    if rest > 0 then n + 1 else n end
+  end
+
+  # Returns the index of the first entry on the current page 
+
+  def current_start_index
+    @current_page * @entries_per_page 
+  end
+
+  # Returns the index of the last page
+
+  def last_page_index
+    num_pages() - 1
+  end
+
+  # Go to first page
+
+  def first
+    goto(0)
+  end
+
+  # Go to last page
+
+  def last
+    goto(last_page_index())
+  end
+
+  # Go to previous page
+  
+  def prev
+    goto(@current_page - 1)
+  end
+
+  # Go to next page 
+
+  def next
+    goto(@current_page + 1)
+  end
+
+  # Go to page with index +page+
+  # Note that page-indices start with zero!
+
+  def goto(page)
+    @current_page = page
+    validate
+  end
+
+  def render
+    return if num_pages() <= 0
+    render_arrow(:first, "<<", "Go to first page"); r.space(2)
+    render_arrow(:prev, "<", "Go to previous page"); r.space(2)
+    render_index; r.space(2)
+    render_arrow(:next, ">", "Go to next page"); r.space(2)
+    render_arrow(:last, ">>", "Go to last page")
+  end
+
+  private
+
+  def render_arrow(sym, text, tooltip=text)
+    r.anchor.callback(sym).tooltip(tooltip).with { r.encode_text(text) }
+  end
+
+  def render_index
+    last = last_page_index()
+    (0 .. last).each do |i|
+      if i == @current_page
+        render_page_num(i, true)
+      else
+        render_page_num(i, false)
+      end
+      r.space if i < last
+    end
+  end
+
+  def render_page_num(num, current)
+    if current
+      r.bold(num+1)
+    else
+      r.anchor.callback(:goto, num).with(num+1)
+    end
+  end
+
+  def validate
+    @current_page = [[0, @current_page].max, last_page_index()].min
+  end
+end

data/lib/wee/continuation/core/component.rb

@@ -20,18 +20,19 @@ class Wee::Component
   # +on_answer+ attribute. Then a Delegate decoration is added to the calling
   # component (self), which delegates to the component to be called
   # (+component+). Then we unwind the calling stack back to the Session by
-  # throwing <i>:wee_back_to_session</i>. This means, that there is only ever
-  # one action callback invoked per request.  When at a later point in time the
-  # called component invokes #answer, this will throw a <i>:wee_answer</i>
-  # exception which is catched in the AnswerDecoration.  The AnswerDecoration
-  # then jumps back to the continuation we created at the beginning, and
-  # finally method #call returns. 
+  # throwing <i>:wee_abort_callback_processing</i>. This means, that there is
+  # only ever one action callback invoked per request.  When at a later point
+  # in time the called component invokes #answer, this will throw a
+  # <i>:wee_answer</i> exception which is catched in the AnswerDecoration.  The
+  # AnswerDecoration then jumps back to the continuation we created at the
+  # beginning, and finally method #call returns. 
   #
   # Note that #call returns to an "old" stack-frame from a previous request.
-  # That is why we throw <i>:wee_back_to_session</i> after invoking an action
-  # callback, and that's why only ever one is invoked. We could remove this
-  # limitation without problems, but then there would be a difference between
-  # those action callbacks that call other components and those that do not.  
+  # That is why we throw <i>:wee_abort_callback_processing</i> after invoking
+  # an action callback, and that's why only ever one is invoked. We could
+  # remove this limitation without problems, but then there would be a
+  # difference between those action callbacks that call other components and
+  # those that do not.  
 
   def call(component, return_callback=:use_continuation, *additional_args)
     add_decoration(delegate = Wee::Delegate.new(component))
@@ -40,7 +41,7 @@ class Wee::Component
     if return_callback == :use_continuation
       result = callcc {|cc|
         answer.on_answer = cc
-        throw :wee_back_to_session
+        throw :wee_abort_callback_processing, nil
       }
       remove_decoration(delegate)
       component.remove_decoration(answer)
@@ -48,7 +49,7 @@ class Wee::Component
     else
       answer.on_answer = OnAnswer.new(self, component, delegate, answer,
                                       return_callback, additional_args)
-      throw :wee_back_to_session
+      throw :wee_abort_callback_processing, nil
     end
   end
 

data/lib/wee/continuation/session.rb

@@ -1,26 +1,9 @@
 require 'timeout'
 
-class Wee::Session
-  def initialize(&block)
-    Thread.current[:wee_session] = self
-
-    @idgen = Wee::SimpleIdGenerator.new
-    @in_queue, @out_queue = SizedQueue.new(1), SizedQueue.new(1)
-
-    block.call(self)
+class Wee::AbstractSession
 
-    raise ArgumentError, "No root component specified" if @root_component.nil?
-    raise ArgumentError, "No page_store specified" if @page_store.nil?
-    
-    @initial_snapshot = snapshot()
-
-    start_request_response_loop
-    super()
-  ensure
-    Thread.current[:wee_session] = nil
-  end
+  # Called by Wee::Application to send the session a request.
 
-  # called by application to send the session a request
   def handle_request(context)
     super
 
@@ -31,6 +14,15 @@ class Wee::Session
     # Wait for the response.
     return @out_queue.pop
   end
+end
+
+class Wee::Session
+  def initialize(&block)
+    super()
+    @in_queue, @out_queue = SizedQueue.new(1), SizedQueue.new(1)
+    setup(&block)
+    start_request_response_loop
+  end
 
   def start_request_response_loop
     Thread.abort_on_exception = true

data/lib/wee/core.rb

@@ -1,15 +1,16 @@
-# The only dependencies of the core classes are:
-#
-# * Wee::Session.current in class Wee::Presenter#session
-# * Wee::DefaultRenderer in Wee::Presenter#renderer_class 
-#
+# There are no dependencies to outer classes!
+
+module Wee; end
 
-# independent files
 require 'wee/core/valueholder'
 require 'wee/core/snapshot'
 require 'wee/core/callback'
+require 'wee/core/page'
+require 'wee/core/context'
+require 'wee/core/idgen'
+require 'wee/core/renderer'
+require 'wee/core/componentrunner'
 
-# dependent files
 require 'wee/core/presenter'
 require 'wee/core/decoration'
 require 'wee/core/component'

data/lib/wee/core/component.rb

@@ -78,32 +78,18 @@ class Wee::Component < Wee::Presenter
   def initialize() # :notnew:
     @__decoration = Wee::ValueHolder.new(self)
     @__children = []
-    @__parent = nil
   end
 
   # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   # :section: Children/Composite
   # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-  public
-
-  # Returns the parent component (or nil if it's the root component).  Note
-  # that if you #call a component, the parent attribute will not be set
-  # automatically.
-
-  def parent
-    @__parent
-  end
-
-  # Reparents the component. You should not call this method yourself!
-
-  def parent=(new_parent)
-    @__parent = new_parent
-  end
-
   protected
 
   # Returns all direct child components collected in an array.
+  # 
+  # You can overwrite this method to return all direct child components of this
+  # component.
  
   def children
     @__children
@@ -127,14 +113,8 @@ class Wee::Component < Wee::Presenter
   #     snapshot.add(self.children)
   #   end
   #
-  # NOTE: Each component has exactly one parent component (or none in the case
-  # of the root component or when using #call). As such, you can't (and should
-  # not!) add a child more than once to another component.
-  #
 
   def add_child(child)
-    raise "Child already has a parent!" if not child.parent.nil?
-    child.parent = self
     self.children << child
     child
   end
@@ -328,10 +308,10 @@ class Wee::Component < Wee::Presenter
   # delegates to the component to be called (+component+). 
   #
   # Then we unwind the calling stack back to the Session by throwing
-  # <i>:wee_back_to_session</i>. This means, that there is only ever one action
-  # callback invoked per request. This is not neccessary, we could simply omit
-  # this, but then we'd break compatibility with the implementation using
-  # continuations.
+  # <i>:wee_abort_callback_processing</i>. This means, that there is only ever
+  # one action callback invoked per request. This is not neccessary, we could
+  # simply omit this, but then we'd break compatibility with the implementation
+  # using continuations.
   #
   # When at a later point in time the called component invokes #answer, this
   # will throw a <i>:wee_answer</i> exception which is catched in the
@@ -345,7 +325,7 @@ class Wee::Component < Wee::Presenter
     component.add_decoration(answer = Wee::AnswerDecoration.new)
     answer.on_answer = OnAnswer.new(self, component, delegate, answer, 
                                     return_callback, args)
-    throw :wee_back_to_session
+    throw :wee_abort_callback_processing, nil 
   end
 
   class OnAnswer < Struct.new(:calling_component, :called_component, :delegate,