wee 0.10.0 → 2.0.0

data/install.rb

@@ -1,14 +0,0 @@
-require 'rbconfig'
-require 'ftools'
-
-# Install lib
-dst_dir = Config::CONFIG['sitelibdir']
-Dir.chdir('lib') { 
-  Dir['**/*'].reject {|f| f =~ /\.svn($|\/)/ or not File.file?(f) }.each {|file|
-    File.mkpath File.join(dst_dir, File.dirname(file)), true
-    File.install file, File.join(dst_dir, file), 0644, true
-  }
-}
-
-# Install bin
-File.install 'bin/wee', File.join(Config::CONFIG['bindir'], 'wee'), 0755, true

data/lib/cache/cache.rb

@@ -1,167 +0,0 @@
-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
-
-# 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/abstractsession.rb

@@ -1,96 +0,0 @@
-require 'thread'
-
-class Wee::AbstractSession < Wee::RequestHandler
-
-  def self.current
-    Thread.current[:wee_session] || (raise "Not in session")
-  end
-
-  def initialize
-    # to serialize the requests we need a mutex
-    @mutex = Mutex.new    
-
-    super()
-  end
-
-  # Returns the current context.
-
-  def current_context
-    @context
-  end
-
-  # Called by Wee::Application to send the session a request.
-
-  def handle_request(context)
-    with_session { 
-      @mutex.synchronize {
-        begin
-          @context = context
-          super
-          awake
-          process_request
-          sleep
-        ensure
-          @context = nil   # clean up
-        end
-      }
-    }
-  rescue Exception => exn
-    set_response(context, Wee::ErrorResponse.new(exn))
-  end
-
-  protected
-
-  def set_response(context, response)
-    context.response = response
-  end
-
-  protected
-
-  # Is called before process_request is invoked.
-  # Can be used to setup e.g. a database connection.
-  # 
-  # OVERWRITE IT (if you like)!
-
-  def awake
-  end
-
-  # Is called after process_request is run.
-  # Can be used to release e.g. a database connection.
-  # 
-  # OVERWRITE IT (if you like)!
-
-  def sleep
-  end
-
-  private
-
-  # The block is run inside a session.
-
-  def with_session
-    Thread.current[:wee_session] = self
-    yield
-  ensure
-    Thread.current[:wee_session] = nil
-  end
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  # :section: Properties
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  public
-
-  def properties() @__properties end
-  def properties=(props) @__properties = props end
-
-  # Returns an "owned" property for the given +klass+.
-
-  def get_property(prop, klass)
-    if self.properties
-      self.properties.fetch(klass, {})[prop]
-    else
-      nil
-    end
-  end
-
-end

data/lib/wee/adaptors/fastcgi.rb

@@ -1,76 +0,0 @@
-require 'fcgi'
-
-Socket.do_not_reverse_lookup = true
-
-# A FastCGI adaptor for Wee.
-# 
-# Depends on ruby-fcgi (http://raa.ruby-lang.org/list.rhtml?name=fcgi) or via
-# Rubygems (gem install fcgi).
-#
-# Example of usage:
-# 
-#   require 'wee/adaptors/fastcgi'
-#   Wee::FastCGIAdaptor.start('/app', application)
-#
-# == Setup FastCGI with Lighttpd
-#
-#   # lighttpd.conf
-#   server.modules = (
-#   "mod_fastcgi"
-#   )
-#   
-#   fastcgi.server = (
-#   "/app" =>
-#     ( "fcgi" =>
-#       (
-#         "host" => 127.0.0.1",
-#         "port" => 3000,
-#         "check-local" => "disable"
-#       )
-#     )
-#   )
-# 
-# Now start the Wee application (the file must be executable):
-# 
-#   spawn-fcgi -f ./run.rb -p 3000
-#
-# Finally start the lighttpd server:
-# 
-#   lighttpd -D -f lighttpd.conf
-#
-
-class Wee::FastCGIAdaptor
-  def self.start(mount_path, application, request_class=Wee::Request)
-    FCGI.each_cgi {|cgi|
-      query = Hash.new
-
-      # TODO: WEBrick like: return a string which has a to_list method!
-      cgi.params.each {|k, v|
-        raise if v.empty?
-        obj = v.first
-        obj.instance_variable_set("@__as_list", v)
-        def obj.as_list() @__as_list end
-
-        query[k] = obj
-      } 
-
-      # TODO
-      header = []
-
-      context = Wee::Context.new(request_class.new(mount_path, 
-        cgi.script_name, header, query, cgi.cookies))
-
-      application.handle_request(context)
-      
-      header = {}
-      header['status'] = context.response.status.to_s
-
-      context.response.header.each { |k,v| header[k] = v }
-      if context.response.cookies?
-        header['cookie'] = context.response.cookies
-      end
-
-      cgi.out(header) { context.response.content }
-    }
-  end
-end

data/lib/wee/adaptors/nitro.rb

@@ -1,155 +0,0 @@
-class Wee::PagelessComponentDriver < Wee::ComponentRunner
-  attr_accessor :callbacks
-
-  def initialize(root_component, callbacks=nil)
-    super(root_component)
-    @callbacks = callbacks
-    @mutex = Mutex.new
-  end
-
-  def render(*args)
-    @mutex.synchronize { super }
-  end
-
-  def process_callbacks(*args)
-    @mutex.synchronize { super }
-  end
-end
-
-class Wee::Presenter
-  def renderer_class
-    Wee::Nitro::HtmlCanvasRenderer
-  end
-end
-
-class Wee::RenderingContext
-  attr_accessor :component_name
-  attr_accessor :controller
-  attr_accessor :redirect_action
-end
-
-
-module Wee::Nitro
-
-  class FormTag < Wee::Brush::FormTag
-    def with(*args, &block)
-      rctx = @canvas.rendering_context
-
-      super(*args) do
-        block.call if block
-        @canvas.hidden_input.name('__c').value(rctx.component_name)
-        @canvas.hidden_input.name('__a').value(rctx.redirect_action) if rctx.redirect_action
-      end
-    end
-  end
-
-  class HtmlCanvasRenderer < Wee::HtmlCanvasRenderer
-    def form(*args, &block)
-      handle(Wee::Nitro::FormTag.new, *args, &block)
-    end
-
-    def build_url(hash={})
-      cid = hash[:callback_id]
-      controller = rendering_context.context.controller_name
-      
-      url = ""
-      url << "/#{ controller }" if controller
-      url << "/callback"
-      url << "?__c=#{ rendering_context.component_name }"
-      url << "&__a=#{ rendering_context.redirect_action }" if rendering_context.redirect_action 
-      url << "&#{ cid }" if cid
-      url
-    end
-  end
-
-  module ControllerClassMixin
-    def register_component(name, &block)
-      registered_components[name] = block
-    end
-
-    def registered_components
-      @@registered_components ||= Hash.new
-    end
-
-    def scaffold_with_component(name=nil, &block)
-      name ||= self.name
-      register_component(name, &block) if block
-      send(:define_method, :index) do
-        show_component name
-      end
-    end
-  end
-
-  module ControllerMixin
-
-    def self.included(klass)
-      klass.extend(ControllerClassMixin)
-    end
-
-    public
-
-    def callback
-      c = components[request.params['__c']]
-      raise "no component found" if c.nil?
-      callback_stream = Wee::CallbackStream.new(c.callbacks, request.params)
-      c.process_callbacks(callback_stream)
-
-      controller = context.controller_name
-      action = request.params['__a'] || 'index'
-      redirect [controller, action].compact.join("/")
-    end
-
-    protected
-
-    def make_component(name, obj)
-      if components.has_key?(name)
-        raise "disallowed to overwrite component #{ name }"
-      else
-        components[name] = Wee::PagelessComponentDriver.new(obj, Wee::CallbackRegistry.new(Wee::SequentialIdGenerator.new))
-      end
-    end
-
-    def drop_component(name)
-      if components.has_key?(name)
-        components.delete(name)
-      else
-        raise "component #{ name } not found"
-      end
-    end
-
-    def has_component?(name)
-      components.has_key?(name)
-    end
-
-    def _show_component(name, hash={}, out='')
-      cb = Wee::CallbackRegistry.new(Wee::SequentialIdGenerator.new)
-      rctx = Wee::RenderingContext.new(context(), cb, Wee::HtmlWriter.new(out))
-      rctx.component_name = name
-      rctx.controller = self
-      rctx.redirect_action = hash[:redirect_action]
-
-      unless c = components[name]
-        if block = self.class.registered_components[name]
-          make_component name, block.call
-          c = components[name]
-        end
-      end
-
-      raise "component #{ name } not found" if c.nil?
-
-      c.render(rctx)
-      c.callbacks = cb
-      out
-    end
-
-    def show_component(name, hash={})
-      _show_component(name, hash, @out)
-    end
-
-    def components
-      session[:COMPONENTS] ||= Hash.new
-    end
-
-  end
-
-end # module Wee::Nitro