mullen-wee 2.2.0

data/lib/wee/state.rb

@@ -0,0 +1,102 @@
+module Wee
+
+  #
+  # This class is for backtracking the state of components (or
+  # decorations/presenters).  Components that want an undo-facility to be
+  # implemented (triggered for example by a browsers back-button), have to
+  # overwrite the Component#state method. Class Wee::State simply
+  # represents a collection of objects from which snapshots were taken via
+  # methods take_snapshot.
+  #
+  class State
+    class Snapshot
+      def initialize(object)
+        @object = object
+        @snapshot = nil
+        @has_snapshot = false
+        @ivars = nil
+      end
+
+      def take
+        @snapshot = @object.take_snapshot unless @has_snapshot
+        @has_snapshot = true
+      end
+
+      def add_ivar(ivar, value)
+        @ivars ||= {}
+        @ivars[ivar] = value
+      end
+
+      def restore
+        @object.restore_snapshot(@snapshot) if @has_snapshot
+        @ivars.each_pair {|k,v| @object.instance_variable_set(k, v) } if @ivars
+      end
+    end
+
+    def initialize
+      @snapshots = Hash.new
+    end
+
+    def add(object)
+      (@snapshots[object.object_id] ||= Snapshot.new(object)).take
+    end
+
+    def add_ivar(object, ivar, value=object.instance_variable_get(ivar))
+      (@snapshots[object.object_id] ||= Snapshot.new(object)).add_ivar(ivar, value)
+    end
+
+    alias << add
+
+    def restore
+      @snapshots.each_value {|snapshot| snapshot.restore}
+    end
+  end # class State
+
+  module DupReplaceSnapshotMixin
+    def take_snapshot
+      dup
+    end
+
+    def restore_snapshot(snap)
+      replace(snap)
+    end
+  end # module DupReplaceSnapshotMixin
+
+  module ObjectSnapshotMixin
+    def take_snapshot
+      snap = Hash.new
+      instance_variables.each do |iv|
+        snap[iv] = instance_variable_get(iv)
+      end
+      snap
+    end
+
+    def restore_snapshot(snap)
+      snap.each do |k,v|
+        instance_variable_set(k, v)
+      end
+    end
+  end # module ObjectSnapshotMixin
+
+  module StructSnapshotMixin
+    def take_snapshot
+      snap = Hash.new
+      each_pair {|k,v| snap[k] = v}
+      snap
+    end
+
+    def restore_snapshot(snap)
+      snap.each_pair {|k,v| send(k.to_s + "=", v)} 
+    end
+  end # module StructSnapshotMixin
+
+end # module Wee
+
+#
+# Extend base classes with snapshot functionality
+#
+class Object; include Wee::ObjectSnapshotMixin end
+class Struct; include Wee::StructSnapshotMixin end
+class Array; include Wee::DupReplaceSnapshotMixin end 
+class String; include Wee::DupReplaceSnapshotMixin end 
+class Hash; include Wee::DupReplaceSnapshotMixin end 

data/lib/wee/task.rb

@@ -0,0 +1,16 @@
+require 'wee/component'
+
+module Wee
+
+  class Task < Component
+
+    def go
+    end
+
+    def render(r)
+      r.session.send_response(RedirectResponse.new(r.url_for_callback(method(:go))))
+    end
+
+  end # class Task
+
+end # module Wee

data/test/bm_render.rb

@@ -0,0 +1,34 @@
+#
+# Render Wee::HelloWorld n-times
+#
+
+$LOAD_PATH.unshift "./lib"
+require 'rubygems'
+require 'wee'
+require 'rack'
+
+class Rack::Request
+  def put?; get? end
+end
+
+class Wee::HtmlWriter
+  def join
+    @port
+  end
+end
+
+root_component = Wee::HelloWorld.new
+Integer(ARGV[0] || raise).times do
+  r = Wee::Renderer.new
+  r.request   = Wee::Request.new({'REQUEST_METHOD' => 'GET', 'SCRIPT_NAME' => 'blah', 'PATH_INFO' => 'blubb',
+  'QUERY_STRING' => '_p=blah&_s=session'})
+  r.document  = Wee::HtmlDocument.new
+  r.callbacks = Wee::Callbacks.new
+
+  begin
+    root_component.decoration.render!(r)
+  ensure
+    r.close
+  end
+  Wee::GenericResponse.new(r.document.join)
+end

data/test/component_spec.rb

@@ -0,0 +1,40 @@
+require 'wee/component'
+
+describe Wee::Component, "when first created" do
+  before do
+    @component = Wee::Component.new
+  end
+
+  it "should have no children" do
+    @component.children.should be_empty
+  end
+
+  it "should have no decoration" do
+    @component.decoration.should == @component 
+  end
+end
+
+describe Wee::Component, "after adding one decoration" do
+  before do
+    @component = Wee::Component.new
+    @decoration = Wee::Decoration.new
+    @component.add_decoration(@decoration)
+  end
+
+  it "should point to the added decoration" do
+    @component.decoration.should == @decoration
+  end
+
+  it "the added decoration should point back to the component" do
+    @component.decoration.next.should == @component
+  end
+
+  it "should return decoration after removing it" do
+    @component.remove_decoration(@decoration).should == @decoration
+  end
+
+  it "should have no decoration after removing it" do
+    @component.remove_decoration(@decoration)
+    @component.decoration.should == @component 
+  end
+end

data/test/stress/plotter.rb

@@ -0,0 +1,84 @@
+class GnuPlot
+  def self.spawn
+    new(IO.popen("gnuplot", "w+"))
+  end
+
+  def initialize(port)
+    @port = port
+  end
+
+  def plot(datasets)
+    @port << "plot" 
+    datasets.each_with_index do |h, i|
+      @port << (i == 0 ? ' ' : ', ')
+      @port << "'-' title '#{ h[:title] }' #{ h[:params] }" 
+    end
+    @port << "\n"
+
+    datasets.each do |h|
+      @port << h[:data].map{|v| v.join(" ")}.join("\n")
+      @port << "\ne\n"
+    end
+
+    self
+  end
+
+  def exit
+    @port << "exit\n"
+    @port.close
+    @port = nil
+  end
+end
+
+class GenericPlotter
+  def initialize(interval, dataset_configs)
+    @interval = interval
+    @datasets = dataset_configs
+    @datasets.each_with_index {|cfg, i|
+      cfg[:params] ||= 'with lines'
+      cfg[:title] ||= i.to_s
+      cfg[:data] ||= []
+    }
+    @gnuplot = GnuPlot.spawn
+  end
+
+  def run
+    Thread.start {
+      @time = 0
+      loop do
+        @datasets.each do |cfg|
+          cfg[:proc].call(cfg[:data], @time) 
+        end
+        @gnuplot.plot(@datasets)
+        sleep @interval
+        @time += @interval
+      end
+    }
+  end
+end
+
+class ObjectPlotter < GenericPlotter
+  def initialize(interval, *klasses)
+    super(interval, klasses.map {|k| 
+      {:title => k.to_s,# :params, 'with linespoints', 
+       :proc => proc {|data, time| data << [time, ObjectSpace.each_object(k) {}] } }
+    })
+  end
+end
+
+class MemoryPlotter < GenericPlotter
+  def initialize(interval, *pids)
+    super(interval, pids.map {|pid| 
+      {:title => "pid: #{ pid }", :proc => proc {|data, time| data << [time, measure_memory(pid)] } }
+    })
+  end
+
+  # return usage of process +pid+ in kb
+  def measure_memory(pid=Process.pid)
+    ["/proc/#{ pid }/status", "/compat/linux/proc/#{ pid }/status"].each {|file|
+      return $1.to_i if File.exists?(file) and File.read(file) =~ /^VmSize:\s*(\d+)\s*kB$/
+    }
+    mem, res = `ps -p #{ pid } -l`.split("\n").last.strip.split(/\s+/)[6..7]
+    return mem.to_i
+  end
+end

data/test/stress/stress_client.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'mechanize'
+
+class StressSession
+  def initialize
+    @agent = WWW::Mechanize.new {|a| 
+      a.max_history = 1
+    }
+    @agent.get('http://localhost:2000/')
+  end
+
+  def click(val)
+    link = @agent.page.links.find {|l| l.node.text == val}
+    @agent.click(link)
+  end
+
+  def submit(val)
+    form = @agent.page.forms.first
+    button = form.buttons.find {|b| b.value == val}
+    @agent.submit(form, button)
+  rescue
+    puts "invalid"
+    p @agent.page
+    p form
+    sleep 5
+  end
+
+  def step
+    %w(OK Cancel).each {|b|
+      click('show')
+      submit('OK')
+      submit(b)
+    }
+    [%w(OK OK), %w(OK Cancel), %w(Cancel OK), %w(Cancel Cancel)].each {|b1, b2|
+      click('show')
+      submit('Cancel')
+      submit(b1)
+      submit(b2)
+    }
+  end
+end
+
+if __FILE__ == $0
+  num_sessions = Integer(ARGV[0] || raise)
+  puts "num_sessions: #{num_sessions}"
+
+  sessions = (1..num_sessions).map { StressSession.new }
+  loop do
+    sessions.each {|s| s.step }
+  end
+end

data/test/stress/stress_local.rb

@@ -0,0 +1,86 @@
+$LOAD_PATH.unshift "../../lib"
+require 'rubygems'
+require 'wee'
+require 'rack/mock'
+
+class HelloWorld < Wee::Component
+
+  class Called2 < Wee::Component
+    def render(r)
+      r.anchor.callback { answer }.with('back')
+    end
+  end
+
+  class Called1 < Wee::Component
+    def render(r)
+      r.anchor.callback { callcc Called2.new; answer }.with('back')
+    end
+  end
+
+  def initialize
+    add_decoration(Wee::PageDecoration.new("Hello World"))
+    @counter = 0
+  end
+
+  def render(r)
+    r.h1 "Hello World from Wee!"
+    r.anchor.callback { callcc Called1.new }.with(@counter.to_s)
+  end
+end
+
+class StressTest
+  def initialize
+    @app = Wee::Application.new {
+      Wee::Session.new(HelloWorld.new, Wee::Session::ThreadSerializer.new)
+    }
+  end
+
+  def request(uri)
+    env = Rack::MockRequest.env_for(uri)
+    resp = @app.call(env)
+    if resp.first == 302
+      request(resp[1]["Location"])
+    else
+      resp.last.body.join
+    end
+  end
+
+  def run(n=10_000, verbose=false)
+    next_uri = '/'
+
+    n.times do
+      p next_uri if verbose
+      body = request(next_uri)
+
+      if body =~ /href="([^"]*)"/
+        next_uri = $1
+      else
+        raise
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  if ARGV.size < 2 or ARGV.size > 3
+    puts %{USAGE: #$0 num_threads num_iters ["verbose"]}
+    exit 1
+  end
+
+  num_threads, num_iters, verbose = Integer(ARGV[0]), Integer(ARGV[1]), ARGV[2] == "verbose"
+
+  if verbose
+    $LOAD_PATH.unshift '.'
+    require 'plotter'
+    MemoryPlotter.new(5, Process.pid).run
+    ObjectPlotter.new(5, Object, Array, String, Hash, Bignum).run
+    ObjectPlotter.new(5, Thread, Continuation, Proc).run
+  end
+
+  app = StressTest.new
+  (1..num_threads).map {
+    Thread.new { app.run(num_iters, verbose) }
+  }.each {|th| th.join}
+
+  STDIN.readline if verbose
+end

data/test/stress/stress_server.rb

@@ -0,0 +1,83 @@
+$LOAD_PATH.unshift '../../lib'
+require 'wee'
+
+class Wee::MessageBox < Wee::Component
+  def initialize(text)
+    @text = text
+  end
+
+  def render(r)
+    r.bold(@text)
+    r.form do
+      r.submit_button.value('OK').callback { answer true }
+      r.space
+      r.submit_button.value('Cancel').callback { answer false }
+    end
+  end
+end
+
+class CallTest < Wee::Component
+  def msgbox(msg, state=nil)
+    if state
+      call Wee::MessageBox.new(msg), &method(state)
+    else
+      call Wee::MessageBox.new(msg), &method(state)
+    end
+  end
+
+  def state1
+    msgbox('A', :state2)
+  end
+
+  def state2(res)
+    res ? msgbox('B') : msgbox('C', :state3)
+  end
+
+  def state3(res)
+    msgbox('D')
+  end
+
+  def render(r)
+    r.anchor.callback { state1 }.with("show")
+  end
+end
+
+class CallTestCC < Wee::Component
+  def msgbox(msg)
+    callcc Wee::MessageBox.new(msg)
+  end
+
+  def render(r)
+    r.anchor.callback {
+      if msgbox('A')
+        msgbox('B')
+      else
+        msgbox('C')
+        msgbox('D')
+      end
+    }.with("show")
+  end
+end
+
+if __FILE__ == $0
+  $LOAD_PATH.unshift '.'
+  require 'plotter'
+  MemoryPlotter.new(5, Process.pid).run
+  ObjectPlotter.new(5, Object, Array, String, Hash, Bignum).run
+  ObjectPlotter.new(5, Thread, Continuation, Proc).run
+
+  mode = ARGV[0]
+  page_cache_capa = Integer(ARGV[1] || 20)
+
+  puts "mode: #{mode}"
+  puts "capa: #{page_cache_capa}"
+  
+  case mode 
+  when 'call'
+    Wee.run { Wee::Session.new(CallTest.new, nil, page_cache_capa) } 
+  when 'callcc'
+    Wee.run { Wee::Session.new(CallTestCC.new, Wee::Session::ThreadSerializer.new, page_cache_capa) }
+  else
+    raise
+  end
+end