mullen-wee 2.2.0

data/lib/wee.rb

@@ -0,0 +1,109 @@
+module Wee
+  Version = "2.2.0"
+end
+
+require 'rack'
+
+require 'wee/state'
+require 'wee/callback'
+
+require 'wee/presenter'
+require 'wee/decoration'
+require 'wee/component'
+require 'wee/root_component'
+require 'wee/task'
+require 'wee/dialog'
+
+require 'wee/application'
+require 'wee/request'
+require 'wee/response'
+require 'wee/session'
+
+require 'wee/html_document'
+require 'wee/html_brushes'
+require 'wee/html_canvas'
+
+if RUBY_VERSION >= "1.9"
+  begin
+    require 'continuation'
+  rescue LoadError
+  end
+end
+
+class Wee::HelloWorld < Wee::RootComponent
+  def render(r)
+    r.text "Hello World from Wee!"
+  end
+end
+
+def Wee.run(component_class=nil, params=nil, &block)
+  raise ArgumentError if component_class and block
+
+  params ||= Hash.new
+  params[:mount_path] ||= '/'
+  params[:port] ||= 2000
+  params[:public_path] ||= nil
+  params[:additional_builder_procs] ||= []
+  params[:use_continuations] ||= true
+  params[:print_message] ||= false
+  params[:autoreload] ||= false
+
+  if component_class <= Wee::RootComponent
+    component_class.external_resources.each do |ext_res|  
+      params[:additional_builder_procs] << proc {|builder| ext_res.install(builder)}
+    end
+  end
+
+  raise ArgumentError if params[:use_continuations] and block 
+
+  unless block
+    block ||= if params[:use_continuations]
+      proc { Wee::Session.new(component_class.instanciate,
+                 Wee::Session::ThreadSerializer.new) }
+    else
+      proc { Wee::Session.new(component_class.instanciate) }
+    end
+  end
+
+  app = Rack::Builder.app do
+    map params[:mount_path] do
+      a = Wee::Application.new(&block)
+
+      if params[:auth_md5]
+        a = Rack::Auth::Digest::MD5.new(a, &params[:auth_md5])
+        a.realm = params[:auth_realm] || 'Wee App'
+        a.opaque = params[:auth_md5_opaque] || Wee::IdGenerator::Secure.new.next
+      end
+
+      if params[:auth_basic]
+        a = Rack::Auth::Basic.new(a, params[:auth_realm] || 'Wee App', &params[:auth_basic])
+      end
+
+      if params[:autoreload]
+        if params[:autoreload].kind_of?(Integer)
+          timer = Integer(params[:autoreload])
+        else
+          timer = 0
+        end
+        use Rack::Reloader, timer 
+      end
+
+      if params[:public_path]
+        run Rack::Cascade.new([Rack::File.new(params[:public_path]), a])
+      else
+        run a
+      end
+    end
+    params[:additional_builder_procs].each {|bproc| bproc.call(self)}
+  end
+
+  if params[:print_message]
+    url = "http://localhost:#{params[:port]}#{params[:mount_path]}"
+    io = params[:print_message].kind_of?(IO) ? params[:print_message] : STDERR
+    io.puts
+    io.puts "Open your browser at: #{url}"
+    io.puts
+  end
+
+  Rack::Handler::WEBrick.run(app, :Port => params[:port])
+end

data/lib/wee/application.rb

@@ -0,0 +1,89 @@
+require 'thread'
+require 'wee/id_generator'
+require 'wee/lru_cache'
+
+module Wee
+
+  #
+  # A Wee::Application manages all Session's of a single application.  It
+  # dispatches the request to the correct handler by examining the request.
+  #
+  class Application
+
+    def self.for(component_class, session_class=Wee::Session, *component_args)
+      new { session_class.new(component_class.new(*component_args)) }
+    end
+
+    class SessionCache < Wee::LRUCache
+      def garbage_collect
+        delete_if {|id, session| session.dead? }
+      end
+    end
+
+    #
+    # Creates a new application. The block, when called, must
+    # return a new Session instance. 
+    #
+    #   Wee::Application.new { Wee::Session.new(root_component) }
+    #
+    def initialize(max_sessions=10_000, &block)
+      @session_factory = block || raise(ArgumentError)
+      @session_ids ||= Wee::IdGenerator::Secure.new
+      @sessions = SessionCache.new(max_sessions)
+      @mutex = Mutex.new
+    end
+
+    #
+    # Garbage collect dead sessions
+    #
+    def cleanup_sessions
+      @mutex.synchronize { @sessions.garbage_collect }
+    end
+    
+    #
+    # Handles a web request
+    #
+    def call(env)
+      request = Wee::Request.new(env)
+
+      if request.session_id
+        session = @mutex.synchronize { @sessions.fetch(request.session_id) }
+        if session and session.alive?
+          session.call(env)
+        else
+          url = request.build_url(:session_id => nil, :page_id => nil)
+          Wee::RefreshResponse.new("Invalid or expired session", url).finish
+        end
+      else
+        session = new_session()
+        url = request.build_url(:session_id => session.id, :page_id => nil)
+        Wee::RedirectResponse.new(url).finish
+      end
+    end
+
+    protected
+
+    def new_session
+      session = @session_factory.call
+      session.application = self
+      insert_session(session)
+      return session
+    end
+
+    def insert_session(session, retries=3)
+      retries.times do
+        @mutex.synchronize {
+          id = @session_ids.next
+          if not @sessions.has_key?(id)
+            @sessions.store(id, session)
+            session.id = id
+            return
+          end
+        }
+      end
+      raise
+    end
+
+  end # class Application
+
+end # module Wee

data/lib/wee/callback.rb

@@ -0,0 +1,109 @@
+module Wee
+
+  class CallbackRegistry
+    def initialize(prefix="")
+      @prefix = prefix
+      @next_id = 0
+      @callbacks = {}    # {callback_id1 => callback1, callback_id2 => callback2}
+      @triggered = nil
+      @obj_map = {}      # obj => [callback_id1, callback_id2, ...]
+    end
+
+    def empty?
+      @callbacks.empty?
+    end
+
+    def register(object, callback)
+      id = @next_id
+      @next_id += 1
+      @callbacks[id] = callback
+      (@obj_map[object] ||= []) << id
+      return "#{@prefix}#{id}"
+    end
+
+    def unregister(object)
+      if arr = @obj_map.delete(object)
+        arr.each {|id| @callbacks.delete(id) }
+      end
+    end
+
+    #
+    # NOTE that if fields named "xxx" and "xxx.yyy" occur, the value of 
+    # @fields['xxx'] is { nil => ..., 'yyy' => ... }. This is required
+    # to make image buttons work correctly.
+    #
+    def prepare_triggered(ids_and_values)
+      @triggered = {}
+      ids_and_values.each do |id, value|
+        if id =~ /^#{@prefix}(\d+)([.](.*))?$/
+          id, suffix = Integer($1), $3
+          next unless @callbacks[id]
+
+          if @triggered[id].kind_of?(Hash)
+            @triggered[id][suffix] = value
+          elsif suffix
+            @triggered[id] = {nil => @triggered[id], suffix => value}
+          else
+            @triggered[id] = value
+          end
+        end
+      end
+    end
+
+    def reset_triggered
+      @triggered = nil
+    end
+
+    def each_triggered(object)
+      if ary = @obj_map[object]
+        for id in ary
+          yield @callbacks[id], @triggered[id] if @triggered.has_key?(id)
+        end
+      end
+    end
+
+    def each_triggered_call_with_value(object)
+      if ary = @obj_map[object]
+        for id in ary
+          @callbacks[id].call(@triggered[id]) if @triggered.has_key?(id)
+        end
+      end
+    end
+
+    def first_triggered(object)
+      if ary = @obj_map[object]
+        for id in ary
+	  return @callbacks[id] if @triggered.has_key?(id)
+        end
+      end
+      return nil
+    end
+
+  end # class CallbackRegistry
+
+  class Callbacks
+    attr_reader :input_callbacks
+    attr_reader :action_callbacks
+
+    def initialize
+      @input_callbacks = CallbackRegistry.new("")
+      @action_callbacks = CallbackRegistry.new("a")
+    end
+
+    def unregister(object)
+      @input_callbacks.unregister(object)
+      @action_callbacks.unregister(object)
+    end
+
+    def with_triggered(ids_and_values)
+      @input_callbacks.prepare_triggered(ids_and_values)
+      @action_callbacks.prepare_triggered(ids_and_values)
+      yield
+    ensure
+      @input_callbacks.reset_triggered
+      @action_callbacks.reset_triggered
+    end
+
+  end # class Callbacks
+
+end # module Wee

data/lib/wee/component.rb

@@ -0,0 +1,363 @@
+require 'wee/presenter'
+require 'wee/decoration'
+
+module Wee
+
+  #
+  # The base class of all components. You should at least overwrite method
+  # #render in your own subclasses.
+  #
+  class Component < Presenter
+
+    #
+    # Constructs a new instance of the component.
+    #
+    # Overwrite this method when you want to use it both as a root component
+    # and as a non-root component. Here you can add neccessary decorations
+    # when used as root component, as for example a PageDecoration or a
+    # FormDecoration. 
+    #
+    # By default this methods adds no decoration.
+    #
+    # See also class RootComponent.
+    #
+    def self.instanciate(*args, &block)
+      new(*args, &block)
+    end
+
+    #
+    # Return an array of classes onto which the current component depends. 
+    # Right now this is only used to determine the required ExternalResources.
+    #
+    def self.depends
+      []
+    end
+
+    #
+    # Initializes a newly created component.
+    #
+    def initialize
+    end
+
+    #
+    # This method renders the content of the component.
+    #
+    # *OVERWRITE* this method in your own component classes to implement the
+    # view. By default this method does nothing!
+    #
+    # [+r+]
+    #    An instance of class <tt>renderer_class()</tt>
+    #
+    def render(r)
+    end
+
+    #
+    # Take snapshots of objects that should correctly be backtracked.
+    #
+    # Backtracking means that you can go back in time of the components' state.
+    # Therefore it is neccessary to take snapshots of those objects that want to
+    # participate in backtracking. Taking snapshots of the whole component tree
+    # would be too expensive and unflexible. Note that methods
+    # <i>take_snapshot</i> and <i>restore_snapshot</i> are called for those
+    # objects to take the snapshot (they behave like <i>marshal_dump</i> and
+    # <i>marshal_load</i>). Overwrite them if you want to define special
+    # behaviour. 
+    #
+    # By default only the decoration chain is backtracked. This is
+    # required to correctly backtrack called components. To disable
+    # backtracking of the decorations, change method
+    # Component#state_decoration to a no-operation:
+    #
+    #   def state_decoration(s)
+    #     # nothing here
+    #   end
+    #
+    # [+s+]
+    #    An object of class State
+    #
+    def state(s)
+      state_decoration(s)
+      for child in self.children
+        child.decoration.state(s)
+      end
+    end
+
+    NO_CHILDREN = [].freeze
+    #
+    # Return all child components.
+    #
+    # *OVERWRITE* this method and return all child components
+    # collected in an array.
+    #
+    def children
+      return NO_CHILDREN
+    end
+
+    #
+    # Process and invoke all input callbacks specified for this component 
+    # and all of it's child components.
+    #
+    # Returns the action callback to be invoked.
+    #
+    def process_callbacks(callbacks)
+      callbacks.input_callbacks.each_triggered_call_with_value(self)
+
+      action_callback = nil
+
+      # process callbacks of all children
+      for child in self.children
+        if act = child.decoration.process_callbacks(callbacks)
+          raise "Duplicate action callback" if action_callback
+          action_callback = act
+        end
+      end
+
+      if act = callbacks.action_callbacks.first_triggered(self)
+        raise "Duplicate action callback" if action_callback
+        action_callback = act
+      end
+
+      return action_callback
+    end
+
+    def state_decoration(s)
+      s.add_ivar(self, :@decoration, @decoration)
+    end
+
+    protected :state_decoration
+
+    # -------------------------------------------------------------
+    # Decoration Methods
+    # -------------------------------------------------------------
+
+    def decoration=(d) @decoration = d end
+    def decoration() @decoration || self end 
+
+    #
+    # Iterates over all decorations
+    # (note that the component itself is excluded)
+    #
+    def each_decoration # :yields: decoration
+      d = @decoration
+      while d and d != self
+        yield d
+        d = d.next
+      end
+    end
+
+    # 
+    # Searches a decoration in the decoration chain
+    #
+    def find_decoration
+       each_decoration {|d| yield d and return d }
+       return nil
+    end
+ 
+    #
+    # Adds decoration +d+ to the decoration chain.
+    #
+    # A global decoration is added in front of the decoration chain, a local
+    # decoration is added in front of all other local decorations but after all
+    # global decorations.
+    #
+    # Returns: +self+
+    #
+    def add_decoration(d)
+      if d.global?
+        d.next = self.decoration
+        self.decoration = d
+      else
+        last_global = nil
+        each_decoration {|i| 
+          if i.global?
+            last_global = i
+          else
+            break
+          end
+        }
+        if last_global.nil?
+          # no global decorations specified -> add in front
+          d.next = self.decoration
+          self.decoration = d
+        else
+          # add after last_global
+          d.next = last_global.next
+          last_global.next = d
+        end
+      end
+
+      return self
+    end
+
+    #
+    # Remove decoration +d+ from the decoration chain. 
+    # 
+    # Returns the removed decoration or +nil+ if it did not exist in the
+    # decoration chain.
+    #
+    def remove_decoration(d)
+      if d == self.decoration  # 'd' is in front
+        self.decoration = d.next
+      else
+        last_decoration = self.decoration
+        next_decoration = nil
+        loop do
+          return nil if last_decoration == self or last_decoration.nil?
+          next_decoration = last_decoration.next
+          break if d == next_decoration
+          last_decoration = next_decoration
+        end
+        last_decoration.next = d.next
+      end
+      d.next = nil  # decoration 'd' no longer is an owner of anything!
+      return d
+    end
+
+    #
+    # Remove all decorations that match the block condition.
+    # 
+    # Example (removes all decorations of class +HaloDecoration+):
+    # 
+    #   remove_decoration_if {|d| d.class == HaloDecoration}
+    #
+    def remove_decoration_if # :yields: decoration
+      to_remove = []
+      each_decoration {|d| to_remove << d if yield d}
+      to_remove.each {|d| remove_decoration(d)}
+    end
+
+    # -------------------------------------------------------------
+    # Call/Answer Methods
+    # -------------------------------------------------------------
+
+    #
+    # Call another component (without using continuations). The calling
+    # component is neither rendered nor are it's callbacks processed
+    # until the called component answers using method #answer. 
+    #
+    # [+component+]
+    #   The component to be called.
+    #
+    # [+return_callback+]
+    #   Is invoked when the called component answers.
+    #
+    # <b>How it works</b>
+    # 
+    # The component to be called is wrapped with an AnswerDecoration and a
+    # Delegate decoration. The latter is used to redirect to the called
+    # component. Once the decorations are installed, we end the processing of
+    # callbacks prematurely.
+    #
+    # When at a later point in time the called component invokes #answer, this
+    # will raise a AnswerDecoration::Answer exception which is catched by the
+    # AnswerDecoration we installed before calling this component, and as such,
+    # whose process_callbacks method was called before we gained control.
+    #
+    # The AnswerDecoration then invokes the <tt>answer_callback</tt> to cleanup
+    # the decorations we added during #call and finally passes control to the
+    # <tt>return_callback</tt>.
+    #
+    def call(component, &return_callback)
+      delegate = Delegate.new(component)
+      answer = AnswerDecoration.new
+      answer.answer_callback = UnwindCall.new(self, component, delegate, answer, &return_callback)
+      add_decoration(delegate)
+      component.add_decoration(answer)
+      session.send_response(nil)
+    end
+
+    protected :call
+
+    #
+    # Reverts the changes made due to Component#call. Is called when
+    # Component#call 'answers'.
+    #
+    class UnwindCall
+      def initialize(calling, called, delegate, answer, &return_callback)
+        @calling, @called, @delegate, @answer = calling, called, delegate, answer
+        @return_callback = return_callback
+      end
+
+      def call(answ)
+        @calling.remove_decoration(@delegate)
+        @called.remove_decoration(@answer)
+        @return_callback.call(*answ.args) if @return_callback
+      end
+    end
+
+    #
+    # Similar to method #call, but using continuations.
+    #
+    def callcc(component)
+      delegate = Delegate.new(component)
+      answer = AnswerDecoration.new
+
+      add_decoration(delegate)
+      component.add_decoration(answer)
+
+      answ = Kernel.callcc {|cc|
+        answer.answer_callback = cc
+        session.send_response(nil)
+      }
+      remove_decoration(delegate)
+      component.remove_decoration(answer)
+
+      args = answ.args
+      case args.size
+      when 0
+        return
+      when 1
+        return args.first
+      else
+        return *args
+      end
+    end
+
+    protected :callcc
+
+    #
+    # Chooses one of #call or #callcc depending on whether a block is
+    # given or not.
+    #
+    def call!(comp, &block)
+      if block
+        call comp, &block
+      else
+        callcc comp
+      end
+    end
+
+    protected :call!
+
+    def call_inline(&render_block)
+      callcc BlockComponent.new(&render_block)
+    end
+
+    protected :call_inline
+
+    #
+    # Return from a called component.
+    # 
+    # NOTE that #answer never returns.
+    #
+    # See #call for a detailed description of the call/answer mechanism.
+    #
+    def answer(*args)
+      raise AnswerDecoration::Answer.new(args)
+    end
+
+    protected :answer
+
+  end # class Component
+
+  class BlockComponent < Component
+    def initialize(&block)
+      @block = block
+    end
+
+    def render(r)
+      instance_exec(r, &@block)
+    end
+  end # class BlockComponent
+
+end # module Wee