wee 0.8.0 → 0.9.0

data/lib/wee/core/componentrunner.rb

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

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

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

data/lib/wee/core/page.rb

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

data/lib/wee/core/presenter.rb

@@ -37,10 +37,10 @@ class Wee::Presenter
   protected
 
   # Returns the current renderer object for use by the render methods.
-  def renderer() @renderer end
+  def renderer() @__renderer end
 
   # Short cut for #renderer.
-  def r() @renderer end
+  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
@@ -48,23 +48,23 @@ class Wee::Presenter
   # the former one and closes the newly created renderer. 
 
   def with_renderer_for(rendering_context) 
-    renderer = renderer_class.new(rendering_context)
-    renderer.current_component = self
-    old_renderer = @renderer 
+    old_renderer = @__renderer
     begin
-      @renderer = renderer
-      yield
+      renderer_class.new(rendering_context, self) {|@__renderer| yield }
     ensure
-      @renderer = old_renderer
-      renderer.close # write outstanding brushes to the document
+      @__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
-    Wee::DefaultRenderer
+    raise "Method renderer_class needs to be implemented!"
   end
 
   # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -97,120 +97,4 @@ class Wee::Presenter
   def backtrack_state(snapshot)
   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_send_response, 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.request, 
-      context.response, 
-      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

data/lib/wee/core/renderer.rb

@@ -0,0 +1,23 @@
+# 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_ext.rb

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

data/lib/wee/databases/og/scaffolder.rb

@@ -164,7 +164,6 @@ class OgScaffolder::Editor < Wee::Component
     r.select_list((1..31).to_a).selected(t.day).callback {|day| set_date_of(prop, day, :day) }
   end
 
-
   def render_buttons
     r.paragraph
     r.submit_button.value('Save').callback(:save)

data/lib/wee/examples/calculator.rb

@@ -0,0 +1,70 @@
+# NEEDS: FormDecoration
+
+class Wee::Examples::Calculator < Wee::Component
+  def initialize
+    super()
+
+    @number_stack = []
+    @input = "" 
+  end
+
+  def render
+    # the number stack
+
+    r.ul { @number_stack.each {|num| r.li(num)} }
+
+    # the display
+
+    r.text_input.value(@input).readonly
+
+    r.space
+
+    r.submit_button.value("Enter").callback(:enter)
+
+    r.submit_button.value("C").callback(:clear)
+
+    r.break
+
+    # the number buttons
+
+    (0..9).each {|num|
+      r.submit_button.value(num).callback(:append, num.to_s)
+    }
+
+    # the decimal point
+
+    r.submit_button.value(".").disabled(@input.include?(".")).callback(:append, '.')
+
+    # binary operators
+
+    ['+', '-', '*', '/'].each { |op|
+      r.submit_button.value(op).callback(:operation, op)
+    }
+  end
+
+  def enter
+    @number_stack << @input.to_f
+    @input = "" 
+  end
+
+  def clear
+    @input = ""
+  end
+
+  def append(str)
+    @input << str 
+  end
+
+  def operation(op)
+    unless @input.empty?
+      @number_stack << @input.to_f
+      @input = ""
+    end
+    if @number_stack.size < 2
+      call Wee::MessageBox.new('Stack underflow!')
+    else
+      r2, r1 = @number_stack.pop, @number_stack.pop
+      @number_stack.push(r1.send(op, r2))
+    end
+  end
+end