wee 0.10.0 → 2.0.0

data/lib/wee/core/componentrunner.rb

@@ -1,73 +0,0 @@
-# Wee::ComponentRunner wraps a root component and provides methods that act on
-# the components tree defined by the root component. 
-
-class Wee::ComponentRunner
-
-  # Values are parameters to method #process_callbacks_of
-
-  DEFAULT_CALLBACK_PROCESSING = [
-    # Invokes all specified input callbacks. NOTE: Input callbacks should never
-    # call other components!
-    [:input, true, false],
-
-    # Invokes the first found action callback. NOTE: Only the first action
-    # callback is invoked. Any other action callback is ignored.
-    [:action, false, true],
-    
-    # Invoke live_update callback (NOTE: only the first is invoked).
-    [:live_update, false, true]
-  ]
-
-  attr_accessor :root_component
-
-  def initialize(root_component)
-    @root_component = root_component
-    @callback_processing = DEFAULT_CALLBACK_PROCESSING 
-  end
-
-  # This method takes a snapshot from the current state of the root component
-  # and returns it.
-
-  def snapshot
-    @root_component.backtrack_state_chain(snap = Wee::Snapshot.new)
-    return snap.freeze
-  end
-
-  # Render the root component with the given rendering context.
-
-  def render(rendering_context)
-    @root_component.do_render_chain(rendering_context)
-  end
-
-  # This method triggers several tree traversals to process the callbacks of
-  # the root component.
-  #
-  # Returns nil or a Response object in case of a premature response.
-
-  def process_callbacks(callback_stream)
-    if callback_stream.all_of_type(:action).size > 1 
-      raise "Not allowed to specify more than one action callback"
-    end
-
-    catch(:wee_abort_callback_processing) { 
-      @callback_processing.each {|args| process_callbacks_of(callback_stream, *args) }
-      nil
-    }
-  end
-
-  protected
-
-  def process_callbacks_of(callback_stream, type, pass_value=true, once=false)
-    @root_component.process_callbacks_chain {|this|
-      callback_stream.with_callbacks_for(this, type) { |callback, value|
-        if pass_value
-          callback.call(value)
-        else
-          callback.call
-        end
-        return if once
-      }
-    }
-  end
-
-end

data/lib/wee/core/context.rb

@@ -1,27 +0,0 @@
-class Wee::Context
-  attr_accessor :request, :response, :session
-
-  def initialize(request=nil, response=nil, session=nil)
-    @request, @response, @session = request, response, session
-  end
-end
-
-class Wee::RenderingContext
-  attr_accessor :context, :callbacks, :document
-
-  def initialize(context=nil, callbacks=nil, document=nil)
-    @context, @callbacks, @document = context, callbacks, document 
-  end
-
-  def request
-    @context.request
-  end
-
-  def response
-    @context.response
-  end
-
-  def session
-    @context.session
-  end
-end

data/lib/wee/core/decoration.rb

@@ -1,138 +0,0 @@
-# Abstract base class of all decorations. Forwards the methods
-# #process_callbacks, #do_render and #backtrack_state to the next decoration in
-# the chain. Subclasses should provide special behaviour in these methods,
-# otherwise the decoration does not make sense.
-#
-# For example, a HeaderFooterDecoration class could draw a header and footer
-# around the decorations or components below itself:
-#
-#   class HeaderFooterDecoration < Wee::Decoration
-#     def do_render(rendering_context)
-#       with_renderer_for(rendering_context) do
-#         render_header
-#         super(rendering_context)
-#         render_footer
-#       end
-#     end
-#
-#     def render_header
-#       r.text "header
-#     end
-#
-#     def render_footer
-#       ...
-#     end
-#   end
-
-class Wee::Decoration < Wee::Presenter
-
-  # Points to the next decoration in the chain. A decoration is responsible for
-  # all decorations or components "below" it (everything that follows this
-  # decoration in the chain). In other words, it's the owner of everything
-  # "below" itself.
-
-  attr_accessor :owner   
-
-  # Is this decoration a global or a local one? By default all decorations are
-  # local unless this method is overwritten.
-  #
-  # 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.
-
-  def global?() false end
-
-  # Forwards method call to the next decoration in the chain.
-
-  def process_callbacks(&block)
-    @owner.process_callbacks(&block)
-  end
-
-  # Forwards method call to the next decoration in the chain.
-
-  def do_render(rendering_context)
-    @owner.do_render(rendering_context)
-  end
-
-  # Forwards method call to the next decoration in the chain.
-
-  def backtrack_state(snapshot)
-    @owner.backtrack_state(snapshot)
-    snapshot.add(self)
-  end
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  # :section: Snapshot
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  # We have to save the @owner attribute to be able to correctly backtrack
-  # calls, as method Wee::Component#call modifies it in the call to
-  # <tt>component.remove_decoration(answer)</tt>. Removing the
-  # answer-decoration has the advantage to be able to call a component more
-  # than once!
-
-  def take_snapshot
-    @owner
-  end
-
-  def restore_snapshot(snap)
-    @owner = snap
-  end
-
-end
-
-# A Wee::Delegate breaks the decoration chain and forwards the methods
-# #process_callbacks, #do_render and #backtrack_state to the corresponding
-# *chain* method of it's _delegate_ component (a Wee::Component).
-
-class Wee::Delegate < Wee::Decoration
-  def initialize(delegate)
-    @delegate = delegate
-  end
-
-  # Forwards method to the corresponding top-level *chain* method of the
-  # _delegate_ component.
-
-  def process_callbacks(&block)
-    @delegate.process_callbacks_chain(&block)
-  end
-
-  # Forwards method to the corresponding top-level *chain* method of the
-  # _delegate_ component.
-
-  def do_render(rendering_context)
-    @delegate.do_render_chain(rendering_context)
-  end
-
-  # Forwards method to the corresponding top-level *chain* method of the
-  # _delegate_ component. We also take snapshots of all non-visible components,
-  # thus we follow the @owner (via super). 
-
-  def backtrack_state(snapshot)
-    super
-    @delegate.backtrack_state_chain(snapshot)
-  end
-end
-
-# A Wee::AnswerDecoration is wrapped around a component that will call
-# Component#answer. This makes it possible to use such components without the
-# need to call them (Component#call), e.g. as child components of other
-# components.
-
-class Wee::AnswerDecoration < Wee::Decoration
-
-  # When a component answers, <tt>on_answer.call(args)</tt> will be executed
-  # (unless nil), where +args+ are the arguments passed to Component#answer.
-  # Note that no snapshot of on_answer is taken, so you should avoid modifying
-  # it!
-
-  attr_accessor :on_answer
-
-  def process_callbacks(&block)
-    args = catch(:wee_answer) { super; nil }
-    if args != nil
-      # return to the calling component 
-      @on_answer.call(*args) if @on_answer
-    end
-  end
-end

data/lib/wee/core/idgen.rb

@@ -1,5 +0,0 @@
-class Wee::IdGenerator
-  def next
-    raise "subclass responsibility"
-  end
-end

data/lib/wee/core/page.rb

@@ -1 +0,0 @@
-class Wee::Page < Struct.new(:snapshot, :callbacks); end

data/lib/wee/core/presenter.rb

@@ -1,100 +0,0 @@
-# Wee::Presenter is the superclass of all classes that want to participate in
-# rendering and callback-processing. Wee::Component and Wee::Decoration are
-# it's two most important subclasses.
-
-class Wee::Presenter
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  # :section: Render
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  public
-
-  # This method renders the content of the presenter.
-  #
-  # *OVERWRITE* this method in your own presenter classes to implement the
-  # view. By default this method does nothing!
-  #
-  # Use the current renderer as returned by #renderer or it's short-cut #r.
-
-  def render
-  end
-
-  # Render the presenter in the given rendering context. <b>DO NOT</b>
-  # overwrite this method, unless you know exactly what you're doing!
-  #
-  # Creates a new renderer object of the class returned by method
-  # #renderer_class, makes this the current renderer, then invokes method
-  # #render.
-  #
-  # [+rendering_context+]
-  #    An object of class RenderingContext
-
-  def do_render(rendering_context)
-    with_renderer_for(rendering_context) do render() end 
-  end
-
-  protected
-
-  # Returns the current renderer object for use by the render methods.
-  def renderer() @__renderer end
-
-  # Short cut for #renderer.
-  def r() @__renderer end
-
-  # Creates a new renderer object of the class returned by method
-  # #renderer_class, then makes this the current renderer for the time the
-  # block it yields to executes. Finally, it restores the current renderer to
-  # the former one and closes the newly created renderer. 
-
-  def with_renderer_for(rendering_context) 
-    old_renderer = @__renderer
-    begin
-      renderer_class.new(rendering_context, self) {|@__renderer| yield }
-    ensure
-      @__renderer = old_renderer
-    end
-  end
-
-  # Returns the class used as renderer for this presenter. Overwrite this
-  # method if you want to use a different renderer.
-  #
-  # Returned class must be a subclass of Wee::Renderer.
-  # 
-  # NEEDS TO BE OVERWRITTEN by some non-core files. 
-
-  def renderer_class
-    raise "Method renderer_class needs to be implemented!"
-  end
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  # :section: Callback
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  public
-
-  # Process all callbacks specified for this presenter. 
-  #
-  # [+block+]
-  #    Specifies the action to be taken (e.g. whether to invoke input or action
-  #    callbacks).
-
-  def process_callbacks(&block)
-    block.call(self)
-  end
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  # :section: Backtrack
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  public
-
-  # Dummy implementation. See Component#backtrack_state for more information. 
-  #
-  # [+snapshot+]
-  #    An object of class Snapshot
-
-  def backtrack_state(snapshot)
-  end
-
-end

data/lib/wee/core/renderer.rb

@@ -1,23 +0,0 @@
-# Base class of all Renderer classes.
-
-class Wee::Renderer
-  attr_reader   :rendering_context   # holds the current Wee::RenderingContext
-  attr_accessor :current_component
-
-  def initialize(rendering_context, current_component=nil, &block)
-    @rendering_context = rendering_context
-    @current_component = current_component
-    if block
-      begin
-        block.call(self)
-      ensure
-        close
-      end
-    end
-  end
-
-  # Subclass responsibility.
-
-  def close
-  end
-end

data/lib/wee/core/snapshot.rb

@@ -1,21 +0,0 @@
-# This class is for backtracking the state of components (or
-# decorations/presenters).  Components that want an undo-facility to be
-# implemented (triggered for example by a browsers back-button), have to
-# overwrite the Component#backtrack_state method. Class Wee::Snapshot simply
-# represents a collection of objects from which snapshots were taken via
-# methods take_snapshot. 
-
-class Wee::Snapshot
-  def initialize
-    @objects = Hash.new
-  end
-
-  def add(object)
-    oid = object.object_id
-    @objects[oid] = [object, object.take_snapshot] unless @objects.include?(oid) 
-  end
-
-  def restore
-    @objects.each_value { |object, value| object.restore_snapshot(value) }
-  end
-end

data/lib/wee/core/valueholder.rb

@@ -1,19 +0,0 @@
-# Implements a value holder. Useful for backtracking the reference assigned to
-# an instance variable (not the object itself!). An example where this is used
-# is the <tt>@__decoration</tt> attribute of class Wee::Component.
-
-class Wee::ValueHolder 
-  attr_accessor :value
-
-  def initialize(value=nil)
-    @value = value
-  end
-
-  def take_snapshot
-    @value
-  end
-
-  def restore_snapshot(value)
-    @value = value
-  end
-end

data/lib/wee/core_ext.rb

@@ -1,122 +0,0 @@
-class Wee::Presenter
-
-  def renderer_class
-    Wee::DefaultRenderer
-  end
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  # :section: Session
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  public
-
-  # Returns the current session. A presenter (or component) has always an
-  # associated session. The returned object is of class Wee::Session or a
-  # subclass thereof.
-
-  def session
-    Wee::Session.current
-  end
-
-  # Send a premature response. 
-
-  protected
-
-  def send_response(response)
-    throw :wee_abort_callback_processing, response
-  end
-
-  # Call the block inside a rendering environment, then send the response prematurely.
-
-  def send_render_response(&block)
-    # Generate a response
-    response = Wee::GenericResponse.new('text/html', '')
-
-    # Get the current context we are in
-    context = session.current_context
-
-    # A rendering context is needed to use 'r' (if you want, you can simply
-    # omit this and just return the response with some html/xml filled in.
-    rendering_context = Wee::RenderingContext.new(
-      context,
-      session.current_callbacks, 
-      Wee::HtmlWriter.new(response.content))
-
-    with_renderer_for(rendering_context, &block)
-
-    send_response(response)
-  end
-
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  # :section: Properties
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  public
-
-  def properties() @__properties end
-  def properties=(props) @__properties = props end
-
-  # Returns an "owned" property.
-
-  def get_property(prop)
-    if self.properties
-      self.properties[prop]
-    else
-      nil
-    end
-  end
-
-  # Tries to lookup a property from different places. +nil+ as property value
-  # is not allowed!
-  # 
-  # Search order:
-  #
-  # 1. self.get_property(prop) 
-  #
-  # 2. session.get_property(prop, self.class) 
-  #
-  # 3. application.get_property(prop, self.class)
-  # 
-  # 4. session.get_property(prop, nil) 
-  #
-  # 5. application.get_property(prop, nil) 
-  #
-  # 6. @@properties[prop] 
-  # 
-
-  def lookup_property(prop)
-    val = get_property(prop)
-    return val if val != nil
-
-    sess = session()
-    app = sess.application
-    klass = self.class
-
-    val = sess.get_property(prop, klass)
-    return val if val != nil
-
-    val = app.get_property(prop, klass)
-    return val if val != nil
-
-    val = sess.get_property(prop, nil)
-    return val if val != nil
-
-    val = app.get_property(prop, nil)
-    return val if val != nil
-
-    if defined?(@@properties)
-      val = @@properties[prop]
-      return val if val != nil
-    end
-
-    return nil
-  end
-
-  # This is currently only used for describing which properties are required by
-  # the underlying component.
-
-  def self.uses_property(*args)
-  end
-
-end