mullen-wee 2.2.0

data/README.rdoc

@@ -0,0 +1,127 @@
+= Wee Web Framework
+
+== Copyright and License
+
+Copyright (c) 2004, 2005, 2009, 2010 by Michael Neumann (mneumann@ntecs.de).
+
+Released under the same terms of license as Ruby.
+
+== Introduction
+
+Wee is a light-weight, very high-level and modern web-framework that makes
+<b>W</b>eb <b>e</b>ngineering <b>e</b>asy. It mainly inherits many ideas and
+features from Seaside[http://seaside.st/], but was written from scratch
+without ever looking at the Seaside (or any other) sources. All code was
+developed from ideas and lots of discussions with Avi Bryant. 
+
+== Features
+
+=== Reusable components
+
+Wee has _real_ components, which are like widgets in a GUI. Once written, you
+can use them everywhere. They are completely independent and do not interfere
+with other components. Components encapsulate state, a view and actions. Of
+course you can use an external model or use templates for rendering.
+
+=== Backtracking
+
+See the <i>What is backtracking?</i> section below. In short, backtracking lets
+the browser's back and forward-button play well together with your application.
+
+=== Clean and concise
+
+Wee is well thought out, is written in *and* supports clean and concise code.
+Furthermore I think most parts are now very well documented.
+
+=== Templating-independent 
+
+Wee does not depend on a special templating-engine. You can use a different
+templating engine for each component if you want. 
+
+=== Powerful programmatic HTML generation 
+
+Wee ships with an easy to use and very powerful programmatic HTML-generation
+library. For example you can create a select list easily with this piece of
+code:
+
+   # select an object from these items
+   items = [1, 2, 3, 4]
+
+   # the labels shown to the user
+   labels = items.map {|i| i.to_s}
+
+   # render it
+   r.select_list(items).labels(labels).callback {|choosen| p choosen}
+
+   # render a multi-select list, with objects 2 and 4 selected
+   r.select_list(items).multi.labels(labels).selected([2,4])
+
+The callback is called with the selected objects from the _items_ array.  Items
+can be any object, even whole components:
+
+   labels = ["msg1", "msg2"]
+   items = labels.collect {|m| MessageBox.new(m)}
+   r.select_list(items).labels(labels).callback {|choosen| call choosen.first} 
+
+== Observations and Limitations
+
+* Components are thread-safe by nature as a fresh components-tree is created
+  for each session and requests inside a session are serialized.
+
+== What is backtracking?
+
+If you want, you can make the back-button of your browser work correctly
+together with your web-application. Imagine you have a simple counter
+application, which shows the current count and two links _inc_ and _dec_ with
+which you can increase or decrease the current count. Starting with an inital
+count of 0 you increase the counter up to 8, then click three times the back
+button of your browser (now displays 5). Finally you decrease by one and
+your counter shows what you'd have expected: 4. In contrast, traditional
+web applications would have shown 7, because the back button usually does
+not trigger a HTTP request and as such the server-side state still has
+a value of 8 for the counter when the request to decrease comes in.
+
+The solution to this problem is to take snapshots of the components state
+after an action is performed and restoring the state before peforming
+actions. Each action generates a new state, which is indicated by
+a so-called <i>page-id</i> within the URL.
+
+== Decorations
+
+Decorations are used to modify the look and behaviour of a component without
+modifying the components tree itself. A component can have more than one
+decoration. Decorations are implemented as a linked list (Wee::Decoration#next
+points to the next decoration), starting at Wee::Component#decoration, which
+either points to the next decoration in the chain, or to itself.
+
+== The request/response cycle
+
+The request/response cycle in Wee is actually split into two separate phases.
+
+=== Render Phase
+
+The rendering phase is assumed to be side-effect free! So, you as a programmer
+should take care to meet this assumption. Rendering is performed by method
+Wee::Component#render!.
+
+=== Action Phase (Invoking Callbacks)
+
+Possible sources for callbacks are links (anchors) and all kinds of
+form-elements like submit buttons, input-fields etc. There are two different
+kinds of callbacks:
+
+* Input callbacks (input-fields)
+
+* Action callbacks (anchor, submit-button)
+
+The distinction between input and action callbacks is important, as action
+callbacks might depend on values of input-fields being assigned to instance
+variables of the controlling component. Hence, Wee first invokes all input
+callbacks before any action callback is triggered. Callback processing
+is performed by method Wee::Component#process_callbacks.
+
+The result of the action phase is an updated components state. As such, a
+snapshot is taken of the new state and stored under a new page-id. Then, a
+redirect requests is sent back to the client, including this new page-id.
+The client automatically follows this redirect and triggers a render phase of
+the new page.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = 'doc/rdoc'
+  rd.rdoc_files.include('lib/**/*.rb', 'README.rdoc')
+  rd.options << '--inline-source' 
+  rd.options << '--all' 
+  rd.options << '--accessor=html_attr=HtmlAttribute'
+  rd.options << '--accessor=generic_tag=GenericTagBrush'
+  rd.options << '--accessor=generic_single_tag=GenericSingleTagBrush'
+  rd.options << '--accessor=brush_tag=Brush'
+end
+
+task :test do
+  sh 'mspec -I./lib -f s test/component_spec.rb'
+end
+
+task :package do
+  sh 'gem build wee.gemspec' 
+end
+
+task :clean => [:clobber_rdoc]
+
+task :default => [:test, :rdoc, :clean]

data/aWee.gemspec

@@ -0,0 +1,26 @@
+require 'rubygems'
+
+if File.read('lib/wee.rb') =~ /Version\s+=\s+"(\d+\.\d+\.\d+)"/
+  version = $1 
+else
+  raise "no version"
+end
+
+spec = Gem::Specification.new do |s|
+  s.name = 'mullen-wee'
+  s.version = version 
+  s.summary = 'Wee is a framework for building highly dynamic web applications.'
+  s.description = 
+    "Wee is a stateful component-orient web framework which supports "
+    "continuations as well as multiple page-states, aka backtracking. "
+    "It is largely inspired by Smalltalk's Seaside framework."
+  s.add_dependency('rack', '>= 1.0.0')
+  s.add_dependency('mspec', '>= 1.5.9')
+  s.add_dependency('fast_gettext', '>= 0.4.17')
+  s.files = Dir['**/*']
+  s.require_path = 'lib'
+  s.author = "Michael Neumann"
+  s.email = "mneumann@ntecs.de"
+  s.homepage = "http://rubyforge.org/projects/wee"
+  s.rubyforge_project = "wee"
+end

data/examples/ObjectSpaceBrowser.rb

@@ -0,0 +1,191 @@
+$LOAD_PATH.unshift << "../lib"
+require 'rubygems'
+require 'wee'
+require 'demo/messagebox'
+require 'enumerator'
+
+module ObjectSpaceBrowser
+
+  class Klasses < Wee::Component
+
+   def klasses
+      ObjectSpace.to_enum(:each_object, Class).sort_by{|k| k.name}
+    end
+
+    def choose(klass)
+      call Klass.new(klass)
+    end
+
+    def render(r)
+      r.h1 "Classes"
+
+      r.ul {
+        klasses.each do |klass|
+          r.li { r.anchor.callback_method(:choose, klass).with(klass.name) }
+        end
+      }
+    end
+  end
+
+  class Klass < Wee::Component
+
+    def initialize(klass)
+      super()
+      @klass = klass
+      set_instances
+    end
+
+    def choose(instance)
+      call Instance.new(instance)
+    end
+
+    ##
+    # Fetches all instances of the klass sorted by object_id
+
+    def set_instances
+      @instances =
+        case @klass
+        when Symbol
+          Symbol.all_symbols.sort_by do |s| s.to_s end
+        else
+          ObjectSpace.to_enum(:each_object, @klass).sort_by{|i| i.object_id}
+        end
+    end
+
+    def render(r)
+      instances = @instances
+      r.h1 "Class #{@klass.name}"
+      r.h2 "#{@instances.length} Instances"
+
+      return if @instances.length.zero?
+
+      r.ul {
+        @instances.each do |instance|
+          r.li { r.anchor.callback_method(:choose, instance).with("0x%x" % instance.object_id) }
+        end
+      }
+    end
+
+  end
+
+  class Instance < Wee::Component
+
+    def initialize(instance)
+      super()
+      @instance = instance
+    end
+
+    def choose(instance)
+      call Instance.new(instance)
+    end
+
+    def back
+      answer
+    end
+
+    def render(r)
+      r.anchor.callback_method(:back).with("back")
+
+      r.break
+      r.h1 "Instance 0x%x of #{@instance.class.name}" % @instance.object_id
+
+      case @instance
+      when Array
+        r.bold("array elements: ")
+        r.break
+        r.ul do
+          @instance.each do |obj|
+            r.li { render_obj(r, obj) }
+          end
+        end
+      when Hash
+        r.bold("hash elements: ")
+        r.break
+        r.table.border(1).with do
+          r.table_row do
+            r.table_data do r.bold("Key") end
+            r.table_data do r.bold("Value") end
+          end
+
+          @instance.each_pair do |k, v|
+            r.table_row do
+              r.table_data { render_obj(r, k) }
+              r.table_data { render_obj(r, v) }
+            end
+          end
+        end
+
+      when String, Float, Fixnum, Bignum, Numeric, Integer, Symbol
+        r.encode_text(@instance.inspect)
+      end
+        
+      return if @instance.instance_variables.empty?
+      r.break
+
+      render_instance_variables(r)
+    end
+
+    def render_instance_variables(r)
+      r.table.border(1).with do
+        r.table_row do
+          r.table_data do r.bold("Instance Variable") end
+          r.table_data do r.bold("Object") end
+        end
+        @instance.instance_variables.each do |var| render_ivar_row(r, var) end
+      end
+    end
+
+    def render_ivar_row(r, var)
+      r.table_row do 
+        r.table_data(var)
+        r.table_data do
+          v = @instance.instance_variable_get(var)
+          render_obj(r, v)
+        end
+      end
+    end
+
+    def render_obj(r, obj)
+      r.anchor.callback_method(:choose, obj).with do
+        r.bold(obj.class.name)
+        r.space
+        r.text("(#{ obj.object_id })")
+        r.space
+        r.space
+
+        case obj
+        when String, Float, Integer, Symbol
+          r.encode_text(obj.inspect)
+        else
+          r.encode_text(obj.inspect[0, 40] + "...")
+        end
+      end 
+    end
+
+  end
+
+end # module ObjectSpaceBrowser
+
+if $0 == __FILE__ then
+
+  OBJ = {
+    "hello" => { [1,2,3] => [5,6,7], "test" => :super },
+    "other" => %w(a b c d e f)
+  }
+
+  class Main < Wee::Component
+    def initialize
+      super
+      add_decoration(Wee::PageDecoration.new("Hello World"))
+      @instance = ObjectSpaceBrowser::Instance.new(OBJ)
+    end 
+
+    def children() [@instance] end
+
+    def render(r)
+      r.render(@instance)
+    end
+  end
+
+  Wee.run(Main)
+end

data/examples/ajax.rb

@@ -0,0 +1,73 @@
+$LOAD_PATH.unshift "../lib"
+require 'rubygems'
+require 'wee'
+require 'rack'
+
+class AjaxCounter < Wee::Component
+
+  #require 'wee/jquery'
+  #def self.depends; [Wee::JQuery] end
+
+  require 'wee/rightjs'
+  def self.depends; [Wee::RightJS] end
+
+  def initialize
+    @counter = 0
+  end
+
+  def state(s)
+    super
+    s.add_ivar(self, :@counter, @counter)
+  end
+
+=begin
+  def style
+    "div.wee-AjaxCounter a { border: 1px solid blue; padding: 5px; background-color: #ABABAB; };"
+  end
+
+  def render(r)
+    r.render_style(self)
+    r.div.css_class('wee-AjaxCounter').oid.with {
+      r.anchor.update_component_on(:click) { @counter += 1 }.with(@counter.to_s)
+    }
+  end
+=end
+
+  def render(r)
+    r.anchor.oid.update_component_on(:click) { @counter += 1 }.with(@counter.to_s)
+  end
+
+end
+
+class HelloWorld < Wee::RootComponent
+
+  def self.depends; [AjaxCounter.depends] end
+
+  def title
+    'Wee + Ajax'
+  end
+
+  def initialize
+    @counters = (1..10).map { AjaxCounter.new }
+  end
+
+  def children() @counters end
+
+  def render(r)
+    render_hello(r)
+    r.div.callback_on(:click) { p "refresh" }.with("Refresh")
+    @counters.each {|c| r.render(c); r.break}
+  end
+
+  def render_hello(r)
+    @hello ||= "Hello"
+    r.div.id("hello").update_on(:click) {|r|
+      @hello.reverse!
+      render_hello(r)
+    }.with(@hello)
+  end
+end
+
+if __FILE__ == $0
+  Wee.run HelloWorld, :mount_path => '/ajax', :print_message => true
+end

data/examples/apotomo-webhunter/main.rb

@@ -0,0 +1,75 @@
+$LOAD_PATH.unshift '../../lib'
+require 'rubygems'
+require 'wee'
+
+class BearTrap < Wee::Component
+  attr_accessor :mouse
+
+  def initialize(is_charged=true)
+    @charged = is_charged
+    add_decoration Wee::OidDecoration.new
+  end
+
+  def render(r)
+    img = @charged ? 'charged' : 'snapped'
+    brush = r.div.id('bear_trap').style("background: transparent url('/images/bear_trap_#{img}.png');")
+    if @charged
+      if @over
+        brush.update_on(:mouseout) {|r|
+          @over = false
+          r.render(self)
+        }
+      else
+        brush.update_on(:mouseover) {|r|
+          @over = true
+          @mouse.update(r)
+          if @mouse.cheese_count >= 3
+            @charged = false
+          end
+          r.render(self)
+          r.javascript("alert('gotcha')") unless @charged
+        }
+      end
+    end
+    brush.with { r.image.src('/images/cheese.png').id('cheese') }
+  end
+end
+
+class Mouse < Wee::Component
+  attr_reader :cheese_count
+
+  def initialize(cheese_count=0)
+    @cheese_count = cheese_count
+  end
+
+  def render(r)
+    r.image.src("/images/mouse.png").id("mouse").width(90 * (@cheese_count+1))
+  end
+
+  def update(r)
+    @cheese_count += 1
+    r.render(self)
+  end
+end
+
+class Main < Wee::Component
+  def initialize
+    super
+    add_decoration Wee::PageDecoration.new('A dark forest...', %w(/stylesheets/forest.css),
+      %w(/javascripts/jquery-1.3.2.min.js /javascripts/wee-jquery.js))
+    @trap = BearTrap.new(true)
+    @mouse = Mouse.new
+    @trap.mouse = @mouse 
+  end
+
+  def children() [@trap, @mouse] end
+
+  def render(r)
+    r.div.id('forest').with {
+      r.render @trap
+      r.render @mouse
+    }
+  end
+end
+
+Wee.run(Main, :public_path => 'public') if __FILE__ == $0