wee 0.4.0 → 0.5.0

data/examples/calculator.rb

@@ -0,0 +1,69 @@
+require 'wee'
+
+class RpnCalculator < Wee::Component
+  def initialize
+    super()
+    add_decoration(Wee::FormDecoration.new)
+
+    @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 {
+      @number_stack << @input.to_f
+      @input = "" 
+    }
+
+    r.break
+
+    # the number buttons
+
+    (0..9).each {|num|
+      r.submit_button.value(num).callback { @input << num.to_s }
+    }
+
+    # the decimal point
+
+    r.submit_button.value(".").disabled(@input.include?(".")).callback { 
+      @input << "."
+    }
+
+    # binary operators
+
+    ['+', '-', '*', '/'].each { |op|
+      r.submit_button.value(op).callback {
+        unless @input.empty?
+          @number_stack << @input.to_f
+          @input = ""
+        end
+        r2, r1 = @number_stack.pop, @number_stack.pop
+        @number_stack.push(r1.send(op, r2))
+      }
+    }
+
+  end
+end
+
+if __FILE__ == $0
+  require 'wee/adaptors/webrick' 
+  require 'wee/utils'
+
+  app = Wee::Utils.app_for { 
+    comp = RpnCalculator.new
+    comp.add_decoration(Wee::PageDecoration.new('RPN Calculator'))
+    comp
+  }
+
+  Wee::WEBrickAdaptor.register('/calc' => app).start 
+end

data/examples/calendar.rb

@@ -3,7 +3,7 @@
 $LOAD_PATH.unshift << "../lib"
 require 'wee'
 require 'wee/adaptors/webrick'
-require 'wee/utils/cache'
+require 'wee/utils'
 require 'date'
 
 class Date
@@ -184,7 +184,7 @@ class MiniCalendar < Wee::Component
   #
   def render_header
     r.table_row do
-      r.table_header.colspan(4).with { r.encoded_text(month_heading) }
+      r.table_header.colspan(4).with { r.encode_text(month_heading) }
       r.table_header { r.anchor.callback { go_prev }.with(prev_month_abbr) }
       r.table_header { r.anchor.callback { go_next }.with(next_month_abbr) }
       r.table_header { browse? ? r.space : r.anchor.callback { back }.style('color: black').with('X') }
@@ -194,7 +194,7 @@ class MiniCalendar < Wee::Component
   # Render Calendar footer
   #
   def render_footer
-    r.table_row { r.table_header.colspan(7).with { r.encoded_text(today_string) } }
+    r.table_row { r.table_header.colspan(7).with { r.encode_text(today_string) } }
   end
   
   # Render Calendar
@@ -316,7 +316,7 @@ if __FILE__ == $0
     #
     def render_icon
       icon = 'http://www.softcomplex.com/products/tigra_calendar/img/cal.gif'
-      r.img.src(icon).width(16).height(16).border(0).alt('Calendar')
+      r.image.src(icon).width(16).height(16).border(0).alt('Calendar')
     end
     
     # Render Calendar demo
@@ -349,18 +349,6 @@ if __FILE__ == $0
     end
   end
 
-  class MySession < Wee::Session
-    def initialize
-      super do
-        self.root_component = CustomCalendarDemo.new
-        self.page_store = Wee::Utils::LRUCache.new(10) # backtrack up to 10 pages
-      end
-    end
-  end
-  
-  app = Wee::Application.new {|app|
-    app.default_request_handler { MySession.new }
-    app.id_generator = Wee::SimpleIdGenerator.new(rand(1_000_000))
-  }
+  app = Wee::Utils.app_for(CustomCalendarDemo)
   Wee::WEBrickAdaptor.register('/app' => app).start
 end

data/examples/example.rb

@@ -204,6 +204,6 @@ end
 
 if __FILE__ == $0
   require 'wee/adaptors/webrick' 
-  require 'wee/utils/helper'
-  Wee::WEBrickAdaptor.register('/app' => Wee::Helper.app_for(MainPage)).start 
+  require 'wee/utils'
+  Wee::WEBrickAdaptor.register('/app' => Wee::Utils.app_for(MainPage)).start 
 end

data/examples/hw.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'wee'
+require 'wee/adaptors/webrick' 
+require 'wee/utils'
+
+class HelloWorld < Wee::Component
+  def initialize
+    super
+    add_decoration(Wee::PageDecoration.new("Hello World"))
+  end
+
+  def render
+    r.h1 "Hello World from Wee!"
+  end
+end
+
+Wee::WEBrickAdaptor.register('/app' => Wee::Utils.app_for(HelloWorld)).start 

data/examples/live-update.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'wee'
+require 'wee/adaptors/webrick' 
+require 'wee/utils'
+
+class LiveUpdateTest < Wee::Component
+  def initialize
+    super
+    add_decoration(Wee::PageDecoration.new("Hello World"))
+    @live_updates = 0
+  end
+
+  def render
+    r.h1 "Hello World from Wee!"
+    r.anchor.callback { @live_updates += 1; do_live_update }.with('live update')
+  end
+
+  def render_live_update
+    r.page { r.text "Live-updates works! This is no. #{ @live_updates }" }
+  end
+
+  def do_live_update
+    # 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_page.callbacks, 
+      Wee::HtmlWriter.new(response.content))
+
+    with_renderer_for(rendering_context) do 
+      # call your own render method for the live-update
+      render_live_update
+    end
+
+    throw :wee_live_update, response
+  end
+end
+
+Wee::WEBrickAdaptor.register('/app' => Wee::Utils.app_for(LiveUpdateTest)).start 

data/examples/og-test.rb

@@ -0,0 +1,51 @@
+# -----------------------------------------
+# The datamodel
+# -----------------------------------------
+
+require 'og'
+
+class Customer
+  prop_accessor :address, String, :sql => 'VARCHAR(100) NOT NULL'
+  prop_accessor :email, String, :sql => 'VARCHAR(50) NOT NULL'
+  prop_accessor :password, String, :sql => 'VARCHAR(10) NOT NULL'
+end
+
+# -----------------------------------------
+# The Wee part
+# -----------------------------------------
+
+require 'wee'
+
+class CustomerList < Wee::Component
+  def initialize
+    super()
+    add_decoration(Wee::PageDecoration.new("Hello World"))
+
+    add_child(@customer_list = OgScaffolder.new(Customer))
+    add_child(@customer_list2 = OgScaffolder.new(Customer))
+  end
+
+  def render
+    r.render @customer_list
+    r.render @customer_list2
+  end
+end
+
+if __FILE__ == $0
+  require 'wee/adaptors/webrick' 
+  require 'wee/utils'
+  require 'wee/databases/og'
+
+  DB_CONFIG = {
+    :address => "localhost",
+    :database => "mneumann",
+    :backend => "psql",
+    :user => "mneumann",
+    :password => "",
+    :connection_count => 10 
+  }
+
+  app = Wee::Utils.app_for(CustomerList, :application => OgApplication, :session => OgSession)
+  app.db = Og::Database.new(DB_CONFIG)
+  Wee::WEBrickAdaptor.register('/app' => app).start
+end

data/lib/wee.rb

@@ -1,5 +1,5 @@
 module Wee
-  Version = "0.4.0"
+  Version = "0.5.0"
 end
 
 require 'wee/core'

data/lib/wee/adaptors/webrick.rb

@@ -19,6 +19,8 @@ require 'webrick'
 #     start(:Port => 2000)
 #
 
+Socket.do_not_reverse_lookup = true
+
 class Wee::WEBrickAdaptor < WEBrick::HTTPServlet::AbstractServlet
 
   # Convenience method

data/lib/wee/application.rb

@@ -102,6 +102,22 @@ class Wee::Application
     context.response = Wee::ErrorResponse.new(exn) 
   end
 
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  # :section: Properties
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+  attr_accessor :properties
+
+  # Returns an "owned" property for the given +klass+.
+
+  def get_property(prop, klass)
+    if @properties
+      @properties.fetch(klass, {})[prop]
+    else
+      nil
+    end
+  end
+
   private
 
   # MUST be called while holding @mutex

data/lib/wee/components.rb

@@ -1 +1,4 @@
+require 'wee/components/wrapper_decoration'
+require 'wee/components/form_decoration'
 require 'wee/components/page_decoration'
+require 'wee/components/messagebox'

data/lib/wee/components/form_decoration.rb

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

data/{test → lib/wee}/components/messagebox.rb

@@ -1,4 +1,4 @@
-class MessageBox < Wee::Component
+class Wee::MessageBox < Wee::Component
   def initialize(text)
     super()
     @text = text 

data/lib/wee/components/page_decoration.rb

@@ -1,4 +1,4 @@
-class Wee::PageDecoration < Wee::Decoration
+class Wee::PageDecoration < Wee::WrapperDecoration
   def initialize(title='')
     @title = title
     super()
@@ -6,9 +6,9 @@ class Wee::PageDecoration < Wee::Decoration
 
   def global?() true end
 
-  def do_render(rendering_context)
-    with_renderer_for(rendering_context) do
-      r.page.title(@title).with { super(rendering_context) }
-    end
+  private
+
+  def render_wrapper
+    r.page.title(@title).with { yield }
   end
 end

data/lib/wee/components/wrapper_decoration.rb

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

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

@@ -0,0 +1,55 @@
+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_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. 
+  #
+  # 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.  
+
+  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_back_to_session
+      }
+      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_back_to_session
+    end
+  end
+
+end

data/lib/wee/continuation/session.rb

@@ -0,0 +1,217 @@
+require 'wee/page'
+require 'thread'
+require 'timeout'
+
+class Wee::Session < Wee::RequestHandler
+  attr_accessor :root_component, :page_store
+
+  def self.current
+    sess = Thread.current[:wee_session]
+    raise "not in session" if sess.nil?
+    return sess
+  end
+
+  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)
+
+    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
+
+  def snapshot
+    @root_component.backtrack_state_chain(snap = Wee::Snapshot.new)
+    return snap.freeze
+  end
+
+  # called by 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
+
+  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
+
+  def create_page(snapshot)
+    idgen = Wee::SimpleIdGenerator.new
+    page = Wee::Page.new(snapshot, Wee::CallbackRegistry.new(idgen))
+  end
+
+  # Is called before process_request is invoked
+  # Can be used to setup e.g. a database connection.
+  def awake
+  end
+
+  # Is called after process_request is run
+  # Can be used to release e.g. a database connection.
+  def sleep
+  end
+
+  def process_request
+    if @context.request.page_id.nil?
+
+      # No page_id was specified in the URL. This means that we start with a
+      # fresh component and a fresh page_id, then redirect to render itself.
+
+      handle_new_page_view(@context, @initial_snapshot)
+
+    elsif @page = @page_store.fetch(@context.request.page_id, false)
+
+      # A valid page_id was specified and the corresponding page exists.
+
+      @page.snapshot.restore
+
+      p @context.request.fields if $DEBUG
+
+      if @context.request.fields.empty?
+
+        # No action/inputs were specified -> render page
+        #
+        # 1. Reset the action/input fields (as they are regenerated in the
+        #    rendering process).
+        # 2. Render the page (respond).
+        # 3. Store the page back into the store
+
+        @page = create_page(@page.snapshot)  # remove all action/input handlers
+        respond(@context, @page.callbacks)                    # render
+        @page_store[@context.request.page_id] = @page         # store
+
+      else
+
+        # Actions/inputs were specified.
+        #
+        # We process the request and invoke actions/inputs. Then we generate a
+        # new page view. 
+
+        callback_stream = Wee::CallbackStream.new(@page.callbacks, @context.request.fields) 
+
+        if callback_stream.all_of_type(:action).size > 1 
+          raise "Not allowed to specify more than one action callback"
+        end
+
+        live_update_response = catch(:wee_live_update) {
+          catch(:wee_back_to_session) {
+            @root_component.process_callbacks_chain(callback_stream)
+          }
+          nil
+        }
+
+        if live_update_response
+          # replace existing page with new snapshot
+          @page.snapshot = self.snapshot
+          @page_store[@context.request.page_id] = @page
+          @context.response = live_update_response
+        else
+          handle_new_page_view(@context)
+        end
+
+      end
+
+    else
+
+      # A page_id was specified in the URL, but there's no page for it in the
+      # page store.  Either the page has timed out, or an invalid page_id was
+      # specified. 
+      #
+      # TODO:: Display an "invalid page or page timed out" message, which
+      # forwards to /app/session-id
+
+      raise "Not yet implemented"
+
+    end
+  end
+
+  def current_context
+    @context
+  end
+
+  def current_page
+    @page
+  end
+
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  # :section: Properties
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+  attr_accessor :properties
+
+  # Returns an "owned" property for the given +klass+.
+
+  def get_property(prop, klass)
+    if @properties
+      @properties.fetch(klass, {})[prop]
+    else
+      nil
+    end
+  end
+
+  private
+
+  def handle_new_page_view(context, snapshot=nil)
+    new_page_id = @idgen.next.to_s
+    new_page = create_page(snapshot || self.snapshot())
+    @page_store[new_page_id] = new_page
+    redirect_url = context.request.build_url(context.request.request_handler_id, new_page_id)
+    context.response = Wee::RedirectResponse.new(redirect_url)
+  end
+
+  def respond(context, callbacks)
+    context.response = Wee::GenericResponse.new('text/html', '')
+
+    rctx = Wee::RenderingContext.new(context.request, context.response, callbacks, Wee::HtmlWriter.new(context.response.content))
+    @root_component.do_render_chain(rctx)
+  end
+
+end