wee 0.1.0

data/lib/cache/cache.rb

@@ -0,0 +1,158 @@
+# Abstract super class of all cache implementations.
+class Cache; end
+
+# Abstract super class of all caching strategies.
+class Cache::Strategy; end
+
+# Implements an unbounded cache strategy. The cache size can grow to infinity.
+class Cache::Strategy::Unbounded < Cache::Strategy
+  class Item < Struct.new(:value); end
+  def item_class() Item end
+
+  def access(item) end
+  def delete(item) end
+  def insert_or_extrude(item, enum) end
+end
+
+# Abstract class for a capacity bounded strategy. Only up to _capacity_ items
+# are allowed to be stored in the cache at any time.
+class Cache::Strategy::CapacityBounded < Cache::Strategy
+  attr_accessor :capacity
+
+  def initialize(capacity)
+    @capacity = capacity
+    @n_items = 0  # number of items in cache
+  end
+
+  def inc(item)
+    raise if full?
+    @n_items += 1
+  end
+
+  def dec(item)
+    raise if empty?
+    @n_items -= 1
+  end
+
+  def full?
+    @n_items >= @capacity 
+  end
+
+  def empty?
+    @n_items == 0
+  end
+end
+
+# Implements the least frequently used (LFU) strategy.
+class Cache::Strategy::LFU < Cache::Strategy::CapacityBounded
+  class Item < Struct.new(:value, :freq); end 
+  def item_class() Item end
+
+  def access(item)
+    item.freq += 1
+  end
+
+  def delete(item)
+    dec(item)
+  end
+
+  # enum::
+  #    a [key, item] enumerable
+  #
+  def insert_or_extrude(item, enum)
+    # find least recently used key/item and yield
+    yield enum.min_by {|key, it| it.freq} while full?
+    item.freq = 0 
+    inc(item)
+  end
+end
+
+# Implements the least recently used (LRU) strategy.
+class Cache::Strategy::LRU < Cache::Strategy::CapacityBounded
+  class Item < Struct.new(:value, :time); end 
+  def item_class() Item end
+
+  def access(item)
+    item.time = Time.now
+  end
+
+  def delete(item)
+    dec(item)
+  end
+
+  # enum::
+  #    a [key, item] enumerable
+  #
+  def insert_or_extrude(item, enum)
+    # find least recently used key/item and yield
+    yield enum.min_by {|key, it| it.time} while full?
+    item.time = Time.now
+    inc(item)
+  end
+end
+
+#
+# Implements a cache using a parameterizable strategy and a storage. 
+# The protocol that the _store_ must understand is: 
+#
+#   fetch(key) -> val
+#   has_key?(key)
+#   delete(key) -> val
+#   each {|key, val| }
+#
+class Cache::StorageCache < Cache
+
+  def initialize(strategy, store=Hash.new, store_on_update=false)
+    @strategy = strategy
+    @store = store
+    @store_on_update = store_on_update
+  end
+
+  def has_key?(key)
+    @store.has_key?(key)
+  end
+
+  def delete(key)
+    if @store.has_key?(key)
+      item = @store.delete(key)
+      @strategy.delete(item)
+      item.value
+    else
+      nil
+    end
+  end
+
+  def fetch(key, default_value=nil)
+    if @store.has_key?(key)
+      item = @store.fetch(key)
+      @strategy.access(item)
+      @store.store(key, item) if @store_on_update
+      item.value
+    else
+      default_value
+    end
+  end
+
+  def store(key, value)
+    if @store.has_key?(key)
+      # update only 
+      item = @store.fetch(key)
+      item.value = value 
+      @strategy.access(item)
+      @store.store(key, item) if @store_on_update
+    else 
+      # insert new item
+      item = @strategy.item_class.new 
+      item.value = value  
+      @strategy.insert_or_extrude(item, @store) do |k, i|
+        @strategy.delete(i)
+        @store.delete(k)
+      end
+      @store.store(key, item) # correct!
+    end
+    value
+  end
+
+  alias [] fetch
+  alias []= store
+end

data/lib/wee.rb

@@ -0,0 +1,11 @@
+module Wee; end
+
+require 'wee/application'
+require 'wee/component'
+require 'wee/delegate_decoration'
+require 'wee/context'
+require 'wee/session'
+require 'wee/holder'
+require 'wee/html_writer'
+require 'wee/html_canvas'
+require 'wee/stuff'

data/lib/wee/application.rb

@@ -0,0 +1,91 @@
+class Wee::Application
+  attr_accessor :name, :path
+  attr_accessor :session_store, :session_class
+  attr_accessor :dumpfile
+
+  def initialize(&block)
+    setup_session_id_generator
+
+    block.call(self)
+
+    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
+
+  def setup_session_id_generator
+    @session_cnt = rand(1000_000)
+  end
+
+  def handle_request(req, res)
+    hash = parse_url(req)
+
+    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
+    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
+
+  def error_invalid_session(req, res)
+    Wee::ErrorPage.new('Invalid Session').respond(Wee::Context.new(req,res,nil,nil))
+  end
+
+  def store_to_disk(dumpfile=nil)
+    File.open(dumpfile||@dumpfile, 'w+b') {|f| f << Marshal.dump(self) }
+  end
+
+  def self.load_from_disk(filename)
+    Marshal.load(File.read(filename))
+  end
+
+  def shutdown
+    store_to_disk
+  end
+
+  private
+
+  # TODO: that's insecure. it's just for development!
+  def gen_unique_session_id
+    (@session_cnt += 1).to_s
+  end
+
+end

data/lib/wee/component.rb

@@ -0,0 +1,126 @@
+class Wee::Component
+
+  attr_accessor :caller # who is calling us
+
+  # call another component
+  def call(component, return_method=nil)
+    component.caller = [self, return_method]
+    add_decoration(Wee::Delegate.new(component))
+  end
+
+  # return from a called component
+  def answer(*args)
+    c, return_method = self.caller
+    c.remove_first_decoration
+    c.send(return_method, *args) if return_method
+  end
+
+  def process_request(context)
+    process_request_inputs(context)
+    children.each {|c| c.decoration.process_request(context) }
+    process_request_actions(context)
+  end
+
+  def process_request_inputs(context)
+    context.request.query.each do |hid, value|
+      if act = context.handler_registry.get_input(hid, self)
+        send(act, value) 
+      end
+    end
+  end
+
+  def process_request_actions(context)
+    # handle URL actions
+    if act = context.handler_registry.get_action(context.handler_id, self)
+      act.invoke
+    end
+
+    # handle form actions
+    context.request.query.each do |hid, value|
+      if act = context.handler_registry.get_action(hid, self)
+        act.invoke
+      end
+    end
+  end
+
+  # Creates a new renderer for this component and renders it.
+  def render_with_context(rendering_context)
+    r = renderer_class.new(rendering_context)
+    r.current_component = self
+    render_content_on(r)
+  end
+
+  # You call render_on to render a component.
+  def render_on(renderer)
+    decoration.render_with_context(renderer.context)
+  end
+
+  def render_content_on(r)
+  end
+
+  def renderer_class
+    Wee::HtmlCanvas
+  end
+
+  def children
+    @children || []
+  end
+
+  def add_child(c)
+    @children ||= []
+    @children << c
+  end
+
+  def add_children(*c)
+    @children ||= []
+    @children.push(*c)
+  end
+
+  # returns the first decoration in the decoration chain, or the component
+  # itself, if none was specified
+
+  attr_writer :decoration
+
+  # FIXME: @decoration may never be self when backtracking
+  # in any case, self==nil
+  def decoration
+    @decoration || self
+  end
+
+  # add decoration _d_ in front of the decoration chain.
+  def add_decoration_in_front(d)
+    d.next = self.decoration
+    self.decoration = d 
+  end
+  alias add_decoration add_decoration_in_front
+
+  def remove_decoration(d)
+    if d == @decoration
+      # d is in front
+      @decoration = d.next
+    else
+      last_decoration = @decoration
+      loop do
+        raise "not found" if last_decoration == self 
+        break if d == last_decoration.next
+        last_decoration = last_decoration.next
+      end
+      last_decoration.next = d.next  
+    end
+  end
+
+  def add_decoration(d)
+    d.next = self.decoration
+    self.decoration = d 
+  end
+
+  def remove_first_decoration
+    self.decoration = self.decoration.next
+    self.decoration = nil if self.decoration == self
+  end
+
+  def session
+    Wee::Session.current
+  end
+
+end

data/lib/wee/context.rb

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

data/lib/wee/delegate_decoration.rb

@@ -0,0 +1,22 @@
+class Wee::Delegate
+  attr_accessor :next   # next decoration in chain
+
+  def initialize(component)
+    @component = component
+  end
+
+  def process_request(context)
+    @component.decoration.process_request(context)
+  end
+
+  # Creates a new renderer for this component and renders it.
+  def render_with_context(rendering_context)
+    r = renderer_class.new(rendering_context)
+    r.current_component = self
+    r.render(@component)
+  end
+
+  def renderer_class
+    Wee::HtmlCanvas
+  end
+end

data/lib/wee/handler_registry.rb

@@ -0,0 +1,89 @@
+class Wee::ActionHandler
+  attr_accessor :obj, :meth, :args
+
+  def self.[](obj, meth, *args)
+    new(obj, meth, *args)
+  end
+
+  def initialize(obj, meth, *args)
+    @obj, @meth, @args = obj, meth.to_s, args
+  end
+
+  def invoke
+    @obj.send(@meth, *@args)
+  end
+end
+
+class Wee::ResourceHandler
+  attr_accessor :content, :content_type
+  def initialize(content, content_type) 
+    @content, @content_type = content, content_type
+  end
+end
+
+class Wee::HandlerRegistry
+  def initialize
+    @next_handler_id = 1
+    @action_registry = Hash.new
+    @input_registry = Hash.new
+    @resource_registry = Hash.new 
+  end
+
+  def handler_id_for_action(action_handler)
+    hid = get_next_handler_id() 
+    raise if @action_registry.has_key?(hid)
+    @action_registry[hid] = action_handler
+    return hid
+  end
+
+  def handler_id_for_input(obj, input)
+    hid = get_next_handler_id() 
+    raise if @input_registry.has_key?(hid)
+    @input_registry[hid] = [obj, input.to_s]
+    return hid
+  end
+
+  def handler_id_for_resource(resource)
+    hid = get_next_handler_id() 
+    raise if @resource_registry.has_key?(hid)
+    @resource_registry[hid] = resource
+    return hid
+  end
+
+  def get_action(handler_id, obj) 
+    action_handler = @action_registry[handler_id]
+    return nil unless action_handler
+
+    if action_handler.obj == obj
+      action_handler 
+    else
+      nil
+    end
+  end
+
+  def get_input(handler_id, obj) 
+    return nil unless @input_registry.has_key?(handler_id)
+
+    component, input = @input_registry[handler_id] 
+
+    if component == obj
+      input 
+    else
+      nil
+    end
+  end
+
+  def get_resource(handler_id)
+    return @resource_registry[handler_id]
+  end
+
+  private
+
+  # TODO: randomize
+  def get_next_handler_id
+    @next_handler_id.to_s
+  ensure
+    @next_handler_id += 1
+  end
+
+end