wee 0.1.0

data/lib/wee/page.rb

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

data/lib/wee/session.rb

@@ -0,0 +1,144 @@
+require 'wee/page'
+require 'wee/state_registry'
+require 'wee/handler_registry'
+require 'thread'
+
+class Wee::Session
+  attr_accessor :root_component, :page_store
+  attr_reader :state_registry
+
+  def self.current
+    sess = Thread.current['Wee::Session']
+    raise "not in session" if sess.nil?
+    return sess
+  end
+
+  def register_object_for_backtracking(obj)
+    @state_registry << obj
+  end
+
+  def initialize(&block)
+    Thread.current['Wee::Session'] = self
+
+    @next_page_id = 0
+    @mutex = Mutex.new
+    @state_registry = Wee::StateRegistry.new
+
+    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 = @state_registry.snapshot 
+
+  ensure
+    Thread.current['Wee::Session'] = nil
+  end
+
+  def setup(context)
+  end
+
+  def handle_request(context)
+    Thread.current['Wee::Session'] = self
+
+    @mutex.synchronize do 
+
+    setup(context)
+
+    if context.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.page_id, false)
+
+      # A valid page_id was specified and the corresponding page exists.
+
+      page.snapshot.apply unless context.resource_id
+
+      raise "invalid request URL! both request_id and handler_id given!" if context.resource_id and context.handler_id
+
+      if context.resource_id
+        # This is a resource request
+        res = page.handler_registry.get_resource(context.resource_id)
+
+        context.response.status = 200
+        context.response['Content-Type'] = res.content_type
+        context.response.body = res.content
+
+      elsif context.handler_id.nil?
+
+        # 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 (only neccessary if page is not
+        #    stored in memory).
+
+        page = Wee::Page.new(page.snapshot, Wee::HandlerRegistry.new)  # remove all action/input handlers
+        context.handler_registry = page.handler_registry
+        respond(context.freeze)                     # render
+        @page_store[context.page_id] = page         # store
+
+      else
+
+        # Actions/inputs were specified.
+        #
+        # We process the request and invoke actions/inputs. Then we generate a
+        # new page view. 
+
+        context.handler_registry = page.handler_registry
+        @root_component.decoration.process_request(context.freeze)
+        handle_new_page_view(context)
+
+      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 # mutex
+
+  ensure
+    Thread.current['Wee::Session'] = nil
+  end
+
+  private
+
+  def handle_new_page_view(context, snapshot=nil)
+    new_page_id = create_new_page_id() 
+    new_page = Wee::Page.new(snapshot || @state_registry.snapshot, Wee::HandlerRegistry.new)
+    @page_store[new_page_id] = new_page
+
+    redirect_url = "#{ context.application.path }/s:#{ context.session_id }/p:#{ new_page_id }"
+    context.response.set_redirect(WEBrick::HTTPStatus::MovedPermanently, redirect_url)
+  end
+
+  def respond(context)
+    context.response.status = 200
+    context.response['Content-Type'] = 'text/html'
+
+    rctx = Wee::RenderingContext.new(context, Wee::HtmlWriter.new(context.response.body))
+    renderer = Wee::HtmlCanvas.new(rctx)
+    @root_component.render_on(renderer)
+  end
+
+  def create_new_page_id
+    @next_page_id.to_s
+  ensure
+    @next_page_id += 1
+  end
+
+end

data/lib/wee/snapshot.rb

@@ -0,0 +1,47 @@
+class Object
+  def take_snapshot
+    snap = Hash.new
+    instance_variables.each do |iv|
+      snap[iv] = instance_variable_get(iv)
+    end
+    snap
+  end
+
+  def apply_snapshot(snap)
+    instance_variables.each do |iv|
+      instance_variable_set(iv, snap[iv])
+    end
+  end
+end
+
+class Array
+  def take_snapshot
+    dup
+  end
+
+  def apply_snapshot(snap)
+    replace(snap)
+  end
+end
+
+class String
+  def take_snapshot
+    dup
+  end
+
+  def apply_snapshot(snap)
+    replace(snap)
+  end
+end
+
+class Struct
+  def take_snapshot
+    snap = Hash.new
+    each_pair {|k,v| snap[k] = v}
+    snap
+  end
+
+  def apply_snapshot(snap)
+    snap.each_pair {|k,v| send(k.to_s + "=", v)} 
+  end
+end

data/lib/wee/state_registry.rb

@@ -0,0 +1,173 @@
+require 'thread'
+require 'set'
+require 'wee/snapshot'
+
+class Wee::StateRegistry
+  def initialize
+    @registered_objects = Hash.new  # { oid => Set:{snap_oid1, snap_oid2}
+    @snap_to_oid_map = Hash.new     # { snap_oid => Set:{oid1, oid2} }
+
+    @finalizer_snap = proc {|snap_oid|
+      Thread.exclusive do
+        @snap_to_oid_map[snap_oid].each do |oid|
+          if r = @registered_objects[oid]
+            r.delete(snap_oid)
+          end
+        end
+        @snap_to_oid_map.delete(snap_oid)
+      end
+    }
+
+    @finalizer_obj = proc {|oid|
+      Thread.exclusive do
+        (@registered_objects.delete(oid) || []).each do |snap_oid|
+          with_object(snap_oid) { |snap|
+            snap.delete(oid)
+            @snap_to_oid_map[snap_oid].delete(oid)
+          }
+        end
+      end
+    }
+  end
+
+  def marshal_load(dump)
+    initialize
+    objs, snaps = dump
+
+    objs.each do |obj|
+      register(obj)
+    end
+
+    snaps.each do |snap|
+      set = (@snap_to_oid_map[snap.object_id] ||= Set.new)
+
+      snap.each do |oid, hash| 
+        set.add(oid)
+        @registered_objects[oid].add(snap.object_id)
+      end
+
+      ObjectSpace.define_finalizer(snap, @finalizer_snap)
+    end
+  end
+
+  # TODO: should do a GC before marshalling?! 
+  # NOTE: we have to marshal the @registered_objects too, as we might have not
+  # yet taken any snapshot
+  def marshal_dump
+    objs = []
+    snaps = []
+
+    each_object {|obj| objs << obj}
+    each_snapshot { |snap| snaps << snap }
+
+    [objs, snaps]
+  end
+
+  def snapshot
+    snap = Snapshot.new
+    set = (@snap_to_oid_map[snap.object_id] ||= Set.new)
+
+    each_object do |obj|
+      snap.add_object(obj)
+      set.add(obj.object_id)
+      @registered_objects[obj.object_id].add(snap.object_id)
+    end
+
+    ObjectSpace.define_finalizer(snap, @finalizer_snap)
+
+    return snap
+  end
+
+  def register(obj)
+    @registered_objects[obj.object_id] ||= Set.new 
+    ObjectSpace.define_finalizer(obj, @finalizer_obj)
+  end
+
+  alias << register
+
+  def each_object(&block)
+    Thread.exclusive do
+      @registered_objects.each_key do |oid|
+        with_object(oid, &block)
+      end
+    end
+  end
+
+  def each_snapshot(&block)
+    Thread.exclusive do
+      @snap_to_oid_map.each_key do |oid|
+        with_object(oid, &block)
+      end
+    end
+  end
+
+  private
+
+  def with_object(oid, &block)
+    begin
+      obj = ObjectSpace._id2ref(oid)
+    rescue RangeError
+      return
+    end
+    block.call(obj) if block
+  end
+
+  class Snapshot
+    def initialize
+      @data = Hash.new
+    end
+
+    def delete(key)
+      @data.delete(key)
+    end
+
+    def each(&block)
+      Thread.exclusive do
+        @data.each(&block)
+      end
+    end
+
+    def add_object(obj)
+      @data[obj.object_id] = obj.take_snapshot
+    end
+
+    def apply
+      each do |oid, snap|
+        with_object(oid) {|obj|
+          obj.apply_snapshot(snap)
+        }
+      end
+    end
+
+    def marshal_dump
+      # generates a { obj => {instance variables} } hash
+      dump = Hash.new
+
+      each do |oid, hash|
+        with_object(oid) {|obj| dump[obj] = hash }
+      end
+
+      dump
+    end
+
+    def marshal_load(dump)
+      initialize
+      dump.each do |obj, hash|
+        @data[obj.object_id] = hash
+      end
+    end
+
+    private
+
+    def with_object(oid, &block)
+      begin
+        obj = ObjectSpace._id2ref(oid)
+      rescue RangeError
+        return
+      end
+      block.call(obj) if block
+    end
+
+  end # class Snapshot
+
+end

data/lib/wee/stuff.rb

@@ -0,0 +1,29 @@
+class Wee::ErrorPage < Wee::Component
+  def initialize(msg)
+    @msg = msg
+    super()
+  end
+
+  def render_content_on(r)
+    r << "<html><head><title>Error: #{@msg}</title><head><body>Error: #{@msg}</body></html>"
+  end
+end
+
+def parse_url(request)
+  hash = {}
+  request.path_info.split('/').each do |part|
+    # we are only interested in "k:v" parts
+    next unless part.include?(':')
+
+    k, v = part.split(/:/, 2)
+    hash[k] = v
+  end
+  hash
+end
+
+# for Ruby 1.8
+module Enumerable
+  def min_by(&block)
+    min {|i,j| block.call(i) <=> block.call(j) }
+  end
+end

data/lib/wee/utils/cache.rb

@@ -0,0 +1,9 @@
+require 'cache/cache'
+
+module Wee::Utils; end
+
+class Wee::Utils::LRUCache < Cache::StorageCache
+  def initialize(capacity=20)
+    super(Cache::Strategy::LRU.new(capacity))
+  end
+end

data/lib/wee/webrick.rb

@@ -0,0 +1,15 @@
+require 'webrick'
+class Wee::Application
+  def start(hash=nil)
+    hash = {:Port => 2000}.update(hash||{})
+    server = WEBrick::HTTPServer.new(hash)
+    server.mount_proc(hash[:mount_path] || self.path) {|req, res| self.handle_request(req, res)}
+    trap("INT") { 
+      trap("INT", "IGNORE")
+      self.shutdown
+      server.shutdown 
+      exit
+    }
+    server.start
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: wee
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2004-11-02
+summary: Wee is a framework for building dynamic dynamic web applications.
+require_paths: 
+  - lib
+author: Michael Neumann
+email: mneumann@ntecs.de
+homepage: http://wee.rubyforge.org
+rubyforge_project: wee
+description: 
+autorequire: wee
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - lib/wee
+  - lib/cache
+  - lib/wee.rb
+  - lib/wee/holder.rb
+  - lib/wee/utils
+  - lib/wee/snapshot.rb
+  - lib/wee/delegate_decoration.rb
+  - lib/wee/session.rb
+  - lib/wee/context.rb
+  - lib/wee/webrick.rb
+  - lib/wee/stuff.rb
+  - lib/wee/handler_registry.rb
+  - lib/wee/html_canvas.rb
+  - lib/wee/html_writer.rb
+  - lib/wee/component.rb
+  - lib/wee/application.rb
+  - lib/wee/state_registry.rb
+  - lib/wee/page.rb
+  - lib/wee/utils/cache.rb
+  - lib/cache/cache.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []