wee 0.10.0 → 2.0.0

data/lib/wee/adaptors/rails.rb

@@ -1,154 +0,0 @@
-class Wee::PagelessComponentDriver < Wee::ComponentRunner
-  attr_accessor :callbacks
-
-  def initialize(root_component, callbacks=nil)
-    super(root_component)
-    @callbacks = callbacks
-    @mutex = Mutex.new
-  end
-
-  def render(*args)
-    @mutex.synchronize { super }
-  end
-
-  def process_callbacks(*args)
-    @mutex.synchronize { super }
-  end
-end
-
-class Wee::Presenter
-  def renderer_class
-    Wee::Rails::HtmlCanvasRenderer
-  end
-end
-
-class Wee::RenderingContext
-  attr_accessor :component_name
-  attr_accessor :controller
-  attr_accessor :redirect_action
-end
-
-module Wee::Rails
-
-  class FormTag < Wee::Brush::FormTag
-    def with(*args, &block)
-      rctx = @canvas.rendering_context
-      controller = rctx.request.path.split('/').first
-
-      super(*args) do
-        block.call if block
-        @canvas.hidden_input.name('__c').value(rctx.component_name)
-        @canvas.hidden_input.name('__a').value(rctx.redirect_action) if rctx.redirect_action
-      end
-    end
-  end
-
-  class HtmlCanvasRenderer < Wee::HtmlCanvasRenderer
-    def form(*args, &block)
-      handle(Wee::Rails::FormTag.new, *args, &block)
-    end
-
-    def build_url(hash={})
-      cid = hash[:callback_id]
-      url = rendering_context.controller.url_for :action => 'callback'
-      url << "?__c=#{ rendering_context.component_name }"
-      url << "&__a=#{ rendering_context.redirect_action }" if rendering_context.redirect_action 
-      url << "&#{ cid }" if cid
-      url
-    end
-  end
-
-  module ControllerClassMixin
-    def register_component(name, &block)
-      registered_components[name] = block
-    end
-
-    def registered_components
-      @@registered_components ||= Hash.new
-    end
-
-    def scaffold_with_component(name=nil, &block)
-      name ||= self.name
-      register_component(name, &block) if block
-      send(:define_method, :index) do
-        show_component name
-      end
-    end
-  end
-
-  module ControllerMixin
-
-    def self.included(klass)
-      klass.extend(ControllerClassMixin)
-    end
-
-    public
-
-    def callback
-      c = components[@params['__c']]
-      raise "no component found" if c.nil?
-      callback_stream = Wee::CallbackStream.new(c.callbacks, @params)
-      c.process_callbacks(callback_stream)
-      redirect_to :action => (@params['__a'] || "index")
-    end
-
-    protected
-
-    def make_component(name, obj)
-      if components.has_key?(name)
-        raise "disallowed to overwrite component #{ name }"
-      else
-        components[name] = Wee::PagelessComponentDriver.new(obj, Wee::CallbackRegistry.new(Wee::SequentialIdGenerator.new))
-      end
-    end
-
-    def drop_component(name)
-      if components.has_key?(name)
-        components.delete(name)
-      else
-        raise "component #{ name } not found"
-      end
-    end
-
-    def has_component?(name)
-      components.has_key?(name)
-    end
-
-    def _show_component(name, hash={}, out='')
-      cb = Wee::CallbackRegistry.new(Wee::SequentialIdGenerator.new)
-      ctx = Wee::Context.new(@request, @response, @session)
-      rctx = Wee::RenderingContext.new(ctx, cb, Wee::HtmlWriter.new(out))
-      rctx.component_name = name
-      rctx.controller = self
-      rctx.redirect_action = hash[:redirect_action]
-
-      unless c = components[name]
-        if block = self.class.registered_components[name]
-          make_component name, block.call
-          c = components[name]
-        end
-      end
-
-      raise "component #{ name } not found" if c.nil?
-
-      c.render(rctx)
-      c.callbacks = cb
-      out
-    end
-
-    def show_component(name, hash={})
-      render_text(_show_component(name, hash))
-    end
-
-    def components
-      @session[:COMPONENTS] ||= Hash.new
-    end
-
-  end
-
-end # module Wee::Rails
-
-class ActionView::Base
-  include Wee::Rails::ControllerMixin
-  alias show_component _show_component
-end

data/lib/wee/adaptors/webrick.rb

@@ -1,89 +0,0 @@
-require 'webrick'
-
-Socket.do_not_reverse_lookup = true
-
-# Example of usage: 
-#
-#   require 'wee/adaptors/webrick'
-#   s = WEBrick::HTTPServer.new(:Port => 2000) 
-#   s.mount '/app', Wee::WEBrickAdaptor, '/app', application
-#
-#   trap("INT") { s.shutdown; exit }
-#   s.start
-#
-# Or when using the convenience methods:
-#
-#   require 'wee/adaptors/webrick'
-#   Wee::WEBrickAdaptor.
-#     request_class(Wee::Request).      # this is the default!
-#     register('/app' => application).
-#     register('/cnt' => application2).
-#     mount('/', WEBrick::HTTPServlet::FileHandler, '.').
-#     start(:Port => 2000)
-#
-
-class Wee::WEBrickAdaptor < WEBrick::HTTPServlet::AbstractServlet
-
-  # Convenience method
-  def self.start(options={})
-    server = WEBrick::HTTPServer.new({:Port => 2000}.update(options))
-    trap("INT") { server.shutdown }
-
-    (@apps||[]).each do |path, app, request_class|
-      server.mount(path, self, path, app, request_class)
-    end
-
-    (@mounts||[]).each do |args, block|
-      server.mount(*args, &block)
-    end
-
-    yield server if block_given?
-
-    server.start
-    server
-  end
-
-  # Sets the used request_class for all following calls to #register
-
-  def self.request_class(request_class)
-    @request_class = request_class
-    self
-  end
-
-  # Convenience method
-  def self.register(hash)
-    @apps ||= []
-    hash.each do |path, application|
-      @apps << [path, application, @request_class]
-    end
-    self
-  end
-
-  # Convenience method
-  def self.mount(*args, &block)
-    @mounts ||= []
-    @mounts << [args, block]
-    self
-  end
-
-  def initialize(server, mount_path, application, request_class=Wee::Request)
-    super(server)
-    @mount_path = mount_path
-    @application = application
-    @request_class = request_class || Wee::Request
-  end
-
-  def handle_request(req, res)
-    context = Wee::Context.new(@request_class.new(@mount_path, req.path, req.header, req.query, req.cookies))
-    @application.handle_request(context)
-    res.status = context.response.status
-    res.body = context.response.content
-    context.response.header.each { |k,v| res.header[k] = v }
-    if context.response.cookies?
-      context.response.cookies.each {|c| res.cookies << c } 
-    end
-  end
-
-  alias do_GET handle_request
-  alias do_POST handle_request
-end

data/lib/wee/components.rb

@@ -1,7 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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/form_decoration.rb

@@ -1,7 +0,0 @@
-class Wee::FormDecoration < Wee::WrapperDecoration
-  private
-
-  def render_wrapper
-    r.form { yield }
-  end
-end

data/lib/wee/components/login_decoration.rb

@@ -1,35 +0,0 @@
-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/page_decoration.rb

@@ -1,14 +0,0 @@
-class Wee::PageDecoration < Wee::WrapperDecoration
-  def initialize(title='')
-    @title = title
-    super()
-  end
-
-  def global?() true end
-
-  private
-
-  def render_wrapper
-    r.page.title(@title).with { yield }
-  end
-end

data/lib/wee/components/wrapper_decoration.rb

@@ -1,7 +0,0 @@
-class Wee::WrapperDecoration < Wee::Decoration
-  def do_render(rendering_context)
-    with_renderer_for(rendering_context) do
-      render_wrapper { super(rendering_context) }
-    end
-  end
-end

data/lib/wee/continuation.rb

@@ -1,5 +0,0 @@
-# Replace the non-continuation based implementation (which is loaded by
-# default) by a continuation enabled implementation.
-
-require 'wee/continuation/session'
-require 'wee/continuation/core/component'

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

@@ -1,56 +0,0 @@
-class Wee::Component
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  # :section: Call/Answer
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  protected
-
-  # Call another component. 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.
-  #
-  # <b>How it works</b>
-  # 
-  # At first a continuation is created. The component to be called is then
-  # wrapped with an AnswerDecoration and the continuation is assigned to it's
-  # +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_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_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))
-    component.add_decoration(answer = Wee::AnswerDecoration.new)
-
-    if return_callback == :use_continuation
-      result = callcc {|cc|
-        answer.on_answer = cc
-        throw :wee_abort_callback_processing, nil
-      }
-      remove_decoration(delegate)
-      component.remove_decoration(answer)
-      return result
-    else
-      answer.on_answer = OnAnswer.new(self, component, delegate, answer,
-                                      return_callback, additional_args)
-      throw :wee_abort_callback_processing, nil
-    end
-  end
-
-end

data/lib/wee/continuation/session.rb

@@ -1,64 +0,0 @@
-require 'timeout'
-
-class Wee::AbstractSession
-
-  # Called by Wee::Application to send the session a request.
-
-  def handle_request(context)
-    super
-
-    # Send a request to the session. If the session is currently busy
-    # processing another request, this will block. 
-    @in_queue.push(context)
-
-    # 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
-    Thread.new {
-      Thread.current[:wee_session] = self
-      loop {
-        @context = nil
-
-        # get a request, check whether this session is alive after every 5
-        # seconds.
-        while @context.nil?
-          begin
-            Timeout.timeout(5) {
-              @context = @in_queue.pop
-            }
-          rescue Timeout::Error
-            break unless alive?
-          end
-        end
-
-        # abort thread if no longer alive
-        break if not alive?
-
-        raise "invalid request" if @context.nil?
-
-        begin
-          awake
-          process_request
-          sleep
-        rescue Exception => exn
-          @context.response = Wee::ErrorResponse.new(exn) 
-        end
-        @out_queue.push(@context)
-      }
-      p "session loop terminated" if $DEBUG
-    }
-  end
-
-end