wee 0.1.0 → 0.3.1

data/examples/window.rb

@@ -0,0 +1,53 @@
+class Wee::Window < Wee::Component
+
+  def initialize(title, pos, child)
+    super()
+    @title = title
+    @child = child
+    @status = :normal  
+    self.children << @child
+    @pos = pos
+  end
+
+  def process_callbacks(callback_stream)
+    return if @status == :closed
+    super
+  end
+
+  def minimize
+    @status = :minimized
+  end
+
+  def maximize
+    @status = :normal
+  end
+
+  def close
+    @status = :closed
+  end
+
+  def render
+    return if @status == :closed
+
+    r.table.cellspacing(0).style("border:solid 1px grey; position: relative; top: #{@pos}; left: #{200+@pos.to_i}").with do
+      r.table_row.style("background-color: lightblue; width: 100%").with do
+        r.table_data.style("text-align: left; width: 66%").with(@title)
+        r.table_data.style("text-align: right").with do
+          if @status == :minimized
+            r.anchor.callback{maximize}.with("#")
+          else
+            r.anchor.callback{minimize}.with("_")
+          end
+          r.space
+          r.anchor.callback{close}.with("X")
+        end
+      end
+      r.table_row do
+        r.table_data.colspan(2).with do
+          r.render(@child) if @status == :normal
+        end
+      end
+    end
+  end
+
+end

data/lib/cache/cache.rb

@@ -1,3 +1,12 @@
+unless Enumerable.instance_methods.include?("min_by")
+  # for Ruby 1.8
+  module Enumerable
+    def min_by(&block)
+      min {|i,j| block.call(i) <=> block.call(j) }
+    end
+  end
+end
+
 # Abstract super class of all cache implementations.
 class Cache; end
 

data/lib/wee.rb

@@ -1,11 +1,21 @@
-module Wee; end
+module Wee
+  Version = "0.3.1"
+end
+
+require 'wee/core'
 
-require 'wee/application'
-require 'wee/component'
-require 'wee/delegate_decoration'
 require 'wee/context'
+require 'wee/application'
+require 'wee/requesthandler'
+require 'wee/request'
+require 'wee/response'
 require 'wee/session'
-require 'wee/holder'
-require 'wee/html_writer'
-require 'wee/html_canvas'
-require 'wee/stuff'
+
+require 'wee/snapshot_ext'
+
+require 'wee/renderer/html/writer'
+require 'wee/renderer/html/brushes'
+require 'wee/renderer/html/canvas'
+Wee::DefaultRenderer = Wee::HtmlCanvas
+
+require 'wee/idgen'

data/lib/wee/adaptors/webrick.rb

@@ -0,0 +1,73 @@
+require 'webrick'
+
+# Example of usage: 
+#
+#   require 'wee/adaptors/webrick'
+#   s = WEBrick::HTTPServer.new(:Port => 2000) 
+#   s.mount '/app', Wee::WEBrickAdaptor, application
+#
+#   trap("INT") { s.shutdown; exit }
+#   s.start
+#
+# Or when using the convenience methods:
+#
+#   require 'wee/adaptors/webrick'
+#   Wee::WEBrickAdaptor.
+#     register('/app' => application).
+#     register('/cnt' => application2).
+#     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|
+      server.mount(path, self, path, app)
+    end
+
+    (@mounts||[]).each do |args, block|
+      server.mount(*args, &block)
+    end
+
+    yield server if block_given?
+
+    server.start
+    server
+  end
+
+  # Convenience method
+  def self.register(hash)
+    @apps ||= []
+    hash.each do |path, application|
+      @apps << [path, application]
+    end
+    self
+  end
+
+  def mount(*args, &block)
+    @mounts ||= []
+    @mounts << [args, block]
+    self
+  end
+
+  def initialize(server, mount_path, application)
+    super(server)
+    @mount_path = mount_path
+    @application = application
+  end
+
+  def handle_request(req, res)
+    context = Wee::Context.new(Wee::Request.new(@mount_path, req.path, req.header, req.query))
+    @application.handle_request(context)
+    res.status = context.response.status
+    res.body = context.response.content
+    context.response.header.each { |k,v| res.header[k] = v }
+  end
+
+  alias do_GET handle_request
+  alias do_POST handle_request
+end

data/lib/wee/application.rb

@@ -1,91 +1,89 @@
+# A Wee::Application manages all Wee::RequestHandler's of a single application,
+# where most of the time the request handlers are Wee::Session objects. It
+# dispatches the request to the correct handler by examining the request.
+
 class Wee::Application
-  attr_accessor :name, :path
-  attr_accessor :session_store, :session_class
-  attr_accessor :dumpfile
 
-  def initialize(&block)
-    setup_session_id_generator
+  # The generator used for creating unique request handler id's.
 
-    block.call(self)
+  attr_accessor :id_generator
 
-    if [@name, @path, @session_class, @session_store, @dumpfile].any? {|i| i.nil?}
-      raise ArgumentError, "missing name, path, session_class, session_store or dumpfile"
-    end
-  end
+  # The maximum number of request handlers
 
-  def setup_session_id_generator
-    @session_cnt = rand(1000_000)
-  end
+  attr_accessor :max_request_handlers
 
-  def handle_request(req, res)
-    hash = parse_url(req)
+  # Get or set the default request handler. The default request handler is used
+  # if no request handler id is given in a request. 
 
-    session_id = hash['s']
-    if session_id.nil? 
-      # TODO:
-      # gen session, or assign default session (by default, do not show).
-      # but for a default session, we have to have thread-safe components (without @context=... hack)
-
-      session = @session_class.new
-      session_id = gen_unique_session_id
-      @session_store[session_id] = session
-    end
-
-    session = @session_store[session_id]
-    if session.nil?
-      # TODO: redirect to session-less page, or do whatever
-      error_invalid_session(req, res); return
+  def default_request_handler(&block)
+    if block.nil?
+      @default_request_handler
+    else
+      @default_request_handler = block
     end
-
-    context = Wee::Context.new(req, res, session, session_id)
-    context.application = self
-    context.session = session
-    context.page_id = hash['p']
-    context.handler_id = hash['h']
-    context.resource_id = hash['r']
-    session.handle_request(context)
-  end
-
-  # TODO: UrlModel, which knows how to create and parse URLs
-  def gen_handler_url(session_id, page_id, handler_id)
-    [
-      self.path, 
-      ['s', session_id].join(':'), 
-      ['p', page_id].join(':'),
-      ['h', handler_id].join(':')
-    ].join('/')
   end
 
-  def gen_resource_url(session_id, page_id, resource_id)
-    [
-      self.path, 
-      ['s', session_id].join(':'), 
-      ['p', page_id].join(':'),
-      ['r', resource_id].join(':')
-    ].join('/')
-  end
+  # Creates a new application. The block is used to initialize the attributes:
+  #
+  #   Wee::Application.new {|app|
+  #     app.default_request_handler { MySession.new } 
+  #     app.id_generator = Wee::SimpleIdGenerator.new
+  #     app.max_request_handlers = 1000 
+  #   }
 
-  def error_invalid_session(req, res)
-    Wee::ErrorPage.new('Invalid Session').respond(Wee::Context.new(req,res,nil,nil))
+  def initialize(&block)
+    @request_handlers = Hash.new
+    block.call(self)
+    @id_generator ||= Wee::SimpleIdGenerator.new(rand(1_000_000))
+    if @default_request_handler.nil?
+      raise ArgumentError, "No default request handler specified"
+    end
+    @mutex = Mutex.new
   end
-
-  def store_to_disk(dumpfile=nil)
-    File.open(dumpfile||@dumpfile, 'w+b') {|f| f << Marshal.dump(self) }
+  
+  # TODO: we have to use mutexes here 
+  # NOTE that id_generator must be thread-safe!
+  # TODO: test for max_request_handlers
+
+  def handle_request(context)
+    @mutex.synchronize do
+      request_handler_id = context.request.request_handler_id
+      request_handler = @request_handlers[request_handler_id]
+
+      if request_handler_id.nil?
+        # No id was given -> create new id and handler
+        request_handler_id = unique_request_handler_id()
+        request_handler = @default_request_handler.call  
+        request_handler.id = request_handler_id
+        request_handler.application = self
+        @request_handlers[request_handler_id] = request_handler
+
+        context.response = Wee::RedirectResponse.new(context.request.build_url(request_handler_id))
+        return
+
+      elsif request_handler.nil?
+        # A false request handler id was given. This might indicate that a
+        # request handler has expired. 
+        request_handler_expired(context)
+        return
+      end
+
+      request_handler.handle_request(context)
+    end
+  rescue => exn
+    context.response = Wee::ErrorResponse.new(exn) 
   end
 
-  def self.load_from_disk(filename)
-    Marshal.load(File.read(filename))
-  end
+  private
 
-  def shutdown
-    store_to_disk
+  def unique_request_handler_id
+    id = @id_generator.next.to_s
+    raise "failed to create unique request handler id" if @request_handlers.include?(id)
+    return id
   end
 
-  private
-
-  # TODO: that's insecure. it's just for development!
-  def gen_unique_session_id
-    (@session_cnt += 1).to_s
+  def request_handler_expired(context)
+    context.response = Wee::RefreshResponse.new("Invalid or expired request handler!", context.request.application_path)
   end
 
 end

data/lib/wee/context.rb

@@ -1,12 +1,2 @@
-class Wee::Context
-  attr_accessor :application
-  attr_accessor :request, :response, :session, :session_id
-  attr_accessor :page_id, :handler_id, :resource_id
-  attr_accessor :handler_registry
-
-  def initialize(request, response, session, session_id)
-    @request, @response, @session, @session_id, @root = request, response, session, session_id
-  end
-end
-
-class Wee::RenderingContext < Struct.new(:context, :document); end
+class Wee::Context < Struct.new(:request, :response); end
+class Wee::RenderingContext < Struct.new(:request, :response, :callbacks, :document); end

data/lib/wee/core.rb

@@ -0,0 +1,15 @@
+# The only dependencies of the core classes are:
+#
+# * Wee::Session.current in class Wee::Presenter#session
+# * Wee::DefaultRenderer in Wee::Presenter#renderer_class 
+#
+
+# independent files
+require 'wee/core/valueholder'
+require 'wee/core/snapshot'
+require 'wee/core/callback'
+
+# dependent files
+require 'wee/core/presenter'
+require 'wee/core/decoration'
+require 'wee/core/component'

data/lib/wee/core/callback.rb

@@ -0,0 +1,108 @@
+# The callback registry is the central datastructure where all components of a
+# session register their callbacks.
+#
+# The format of the internal datastructure is:
+#
+#   @callbacks[type][callback_id] => callback
+#   @obj_to_id_map[type][object] => [id*]
+
+class Wee::CallbackRegistry
+
+  def initialize(id_generator)
+    @idgen = id_generator
+    @callbacks = Hash.new
+    @obj_to_id_map = Hash.new
+  end
+
+  # Register +callback+ for +object+ under +type+ and return a unique callback id. 
+
+  def register_for(object, type=nil, &callback)
+    c = (@callbacks[type] ||= Hash.new)
+    o = (@obj_to_id_map[type] ||= Hash.new) 
+    cid = @idgen.next.to_s
+    raise "duplicate callback id" if c.has_key?(cid)
+    c[cid] = callback
+    (o[object] ||= []) << cid  
+    return cid
+  end
+
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  # :section: Friend methods for Wee::CallbackStream
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+  def get_ids_for(object, type=nil)
+    if o = @obj_to_id_map[type]
+      o[object] || []
+    else
+      []
+    end
+  end
+
+  def get_callback_for(id, type=nil)
+    if c = @callbacks[type]
+      c[id]
+    else
+      raise
+    end
+  end
+
+  def all_of_type(type=nil)
+    if c = @callbacks[type]
+      c
+    else
+      raise
+    end
+  end
+
+end
+
+
+# The intersection of registered callbacks and those that occured. 
+
+class Wee::CallbackStream
+  
+  #
+  # [<tt>callbacks</tt>]
+  #   A Wee::CallbackRegistry
+  #
+  # [<tt>ids_and_values</tt>]
+  #   A hash that contains all callback ids together with their values that
+  #   occurend in a request, e.g. { id => value }.
+
+  def initialize(callbacks, ids_and_values)
+    @callbacks = callbacks
+    @ids_and_values = ids_and_values
+    @ids = @ids_and_values.keys 
+  end
+
+  def with_callbacks_for(object, type)
+    matching_ids = @callbacks.get_ids_for(object, type) & @ids 
+    matching_ids.each do |id|
+      yield @callbacks.get_callback_for(id, type), @ids_and_values[id] 
+    end
+    @ids -= matching_ids
+  end
+
+  # Returns a [callback, value] array of all callbacks of +type+ for which an
+  # id was given. 
+
+  def all_of_type(type)
+    a = [] 
+    @callbacks.all_of_type(type).each {|id, callback|
+      a << [callback, @ids_and_values[id]]  if @ids_and_values.include?(id)
+    }
+    return a
+  end
+
+end
+
+# A serializable callback. 
+class Wee::LiteralMethodCallback
+  def initialize(obj, method_id=:call)
+    @obj, @method_id = obj, method_id
+  end
+
+  def call(*args)
+    @obj.send(@method_id, *args)
+  end
+end