wee 0.4.0 → 0.5.0

data/lib/wee/core/callback.rb

@@ -16,7 +16,7 @@ class Wee::CallbackRegistry
 
   # Register +callback+ for +object+ under +type+ and return a unique callback id. 
 
-  def register_for(object, type=nil, &callback)
+  def register_for(object, type, callback)
     c = (@callbacks[type] ||= Hash.new)
     o = (@obj_to_id_map[type] ||= Hash.new) 
     cid = @idgen.next.to_s
@@ -30,7 +30,7 @@ class Wee::CallbackRegistry
   # :section: Friend methods for Wee::CallbackStream
   # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-  def get_ids_for(object, type=nil)
+  def get_ids_for(object, type)
     if o = @obj_to_id_map[type]
       o[object] || []
     else
@@ -38,7 +38,7 @@ class Wee::CallbackRegistry
     end
   end
 
-  def get_callback_for(id, type=nil)
+  def get_callback_for(id, type)
     if c = @callbacks[type]
       c[id]
     else
@@ -46,7 +46,7 @@ class Wee::CallbackRegistry
     end
   end
 
-  def all_of_type(type=nil)
+  def all_of_type(type)
     if c = @callbacks[type]
       c
     else
@@ -98,11 +98,16 @@ end
 
 # A serializable callback. 
 class Wee::LiteralMethodCallback
-  def initialize(obj, method_id=:call)
+  def initialize(obj, method_id=:call, *additional_args)
     @obj, @method_id = obj, method_id
+    @additional_args = additional_args unless additional_args.empty?
   end
 
   def call(*args)
-    @obj.send(@method_id, *args)
+    if @additional_args
+      @obj.send(@method_id, *(args+@additional_args))
+    else
+      @obj.send(@method_id, *args)
+    end
   end
 end

data/lib/wee/core/component.rb

@@ -114,6 +114,7 @@ class Wee::Component < Wee::Presenter
 
   def add_child(child)
     self.children << child
+    child
   end
 
   # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -282,46 +283,57 @@ class Wee::Component < Wee::Presenter
   # [+component+]
   #   The component to be called.
   #
+  # [+return_callback+]
+  #   Is invoked when the called component answers.
+  #   Either a symbol or any object that responds to #call. If it's a symbol,
+  #   then the corresponding method of the current component will be called.
+  #
+  # [+additional_args+]
+  #   Additional arguments that are passed (after the arguments given in
+  #   #answer) to the +return_callback+
+  #
   # <b>How it works</b>
   # 
-  # At first a continuation is created. The component to be called is then
-  # wrapped with an AnswerDecoration and the continuation is assigned to it's
-  # +on_answer+ attribute. Then a Delegate decoration is added to the calling
-  # component (self), which delegates to the component to be called
-  # (+component+). Then we unwind the calling stack back to the Session by
-  # throwing <i>:wee_back_to_session</i>. This means, that there is only ever
-  # one action callback invoked per request.  When at a later point in time the
-  # called component invokes #answer, this will throw a <i>:wee_answer</i>
-  # exception which is catched in the AnswerDecoration.  The AnswerDecoration
-  # then jumps back to the continuation we created at the beginning, and
-  # finally method #call returns. 
+  
+  # The component to be called is wrapped with an AnswerDecoration and the
+  # +return_callback+ parameter is assigned to it's +on_answer+ attribute (not
+  # directly as there are cleanup actions to be taken before the
+  # +return_callback+ can be invoked, hence we wrap it in the OnAnswer class).
+  # Then a Delegate decoration is added to the calling component (self), which
+  # delegates to the component to be called (+component+). 
   #
-  # Note that #call returns to an "old" stack-frame from a previous request.
-  # That is why we throw <i>:wee_back_to_session</i> after invoking an action
-  # callback, and that's why only ever one is invoked. We could remove this
-  # limitation without problems, but then there would be a difference between
-  # those action callbacks that call other components and those that do not.  
+  # Then we unwind the calling stack back to the Session by throwing
+  # <i>:wee_back_to_session</i>. This means, that there is only ever one action
+  # callback invoked per request. This is not neccessary, we could simply omit
+  # this, but then we'd break compatibility with the implementation using
+  # continuations.
+  #
+  # When at a later point in time the called component invokes #answer, this
+  # will throw a <i>:wee_answer</i> exception which is catched in the
+  # AnswerDecoration. The AnswerDecoration then invokes the +on_answer+
+  # callback which cleans up the decorations we added during #call, and finally
+  # passes control to the +return_callback+. 
 
-  def call(component, return_callback=:use_continuation)
+  def call(component, return_callback=nil, *additional_args)
     add_decoration(delegate = Wee::Delegate.new(component))
     component.add_decoration(answer = Wee::AnswerDecoration.new)
+    answer.on_answer = OnAnswer.new(self, component, delegate, answer, 
+                                    return_callback, additional_args)
+    throw :wee_back_to_session
+  end
 
-    if return_callback == :use_continuation
-      result = callcc {|cc|
-        answer.on_answer = cc
-        throw :wee_back_to_session
-      }
-      remove_decoration(delegate)
-      component.remove_decoration(answer)
-      return result
-    else
-      # TODO: make this marshallable! 
-      answer.on_answer = proc {|*args|
-        remove_decoration(delegate)
-        component.remove_decoration(answer)
-        return_callback.call(*args)
-      }
-      throw :wee_back_to_session
+  class OnAnswer < Struct.new(:calling_component, :called_component, :delegate, 
+                              :answer, :return_callback, :additional_args)
+
+    def call(*args)
+      calling_component.remove_decoration(delegate)
+      called_component.remove_decoration(answer)
+      return if return_callback.nil?
+      if return_callback.respond_to?(:call)
+        return_callback.call(*(args + additional_args))
+      else
+        calling_component.send(return_callback, *(args + additional_args))
+      end
     end
   end
 

data/lib/wee/core/presenter.rb

@@ -129,4 +129,72 @@ class Wee::Presenter
     Wee::Session.current
   end
 
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  # :section: Properties
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+  attr_accessor :properties
+
+  # Returns an "owned" property.
+
+  def get_property(prop)
+    if @properties
+      @properties[prop]
+    else
+      nil
+    end
+  end
+
+  # Tries to lookup a property from different places. +nil+ as property value
+  # is not allowed!
+  # 
+  # Search order:
+  #
+  # 1. self.get_property(prop) 
+  #
+  # 2. session.get_property(prop, self.class) 
+  #
+  # 3. application.get_property(prop, self.class)
+  # 
+  # 4. session.get_property(prop, nil) 
+  #
+  # 5. application.get_property(prop, nil) 
+  #
+  # 6. @@properties[prop] 
+  # 
+
+  def lookup_property(prop)
+    val = get_property(prop)
+    return val if val != nil
+
+    sess = session()
+    app = sess.application
+    klass = self.class
+
+    val = sess.get_property(prop, klass)
+    return val if val != nil
+
+    val = app.get_property(prop, klass)
+    return val if val != nil
+
+    val = sess.get_property(prop, nil)
+    return val if val != nil
+
+    val = app.get_property(prop, nil)
+    return val if val != nil
+
+    if defined?(@@properties)
+      val = @@properties[prop]
+      return val if val != nil
+    end
+
+    return nil
+  end
+
+  # This is currently only used for describing which properties are required by
+  # the underlying component.
+
+  def self.uses_property(*args)
+  end
+
 end

data/lib/wee/databases/og.rb

@@ -0,0 +1,114 @@
+require 'og'
+
+class OgApplication < Wee::Application
+  attr_accessor :db
+end
+
+class OgSession < Wee::Session
+  def awake
+    application.db.get_connection
+  end
+
+  def sleep
+    application.db.put_connection
+  end
+end
+
+class OgScaffolder < Wee::Component
+  def initialize(domain_class)
+    super()
+    @domain_class = domain_class
+    @attributes = domain_class.__props.map {|a| a.name}.reject {|a| a == 'oid'}
+  end
+
+  def delete(obj)
+    call Wee::MessageBox.new('Really delete?'), :confirm_delete, obj
+  end
+
+  def confirm_delete(confirmed, obj)
+    if confirmed
+      @objs.delete(obj)
+      obj.delete!
+    end
+  end
+
+  def edit(obj)
+    @edit = obj
+  end
+
+  def save(obj)
+    obj.save!
+    @edit = nil
+  end
+ 
+  def cancel
+    @objs.delete(@edit) if @edit and @edit.oid.nil?
+    @edit = nil
+  end
+
+  def refresh
+    @objs = @domain_class.all || []
+  end
+
+  def create
+    @objs << (@edit = @domain_class.new)
+  end
+
+  def render
+    refresh if @objs.nil?
+
+    r.h1 "#{ @domain_class } List"
+    r.anchor.callback { refresh }.with("Refresh")
+
+    r.form do
+      r.table.border(1).with {
+
+        r.table_row.with {
+          @attributes.each {|a|
+            r.table_header.with {
+              r.bold(a.capitalize)
+            }
+          }
+          r.table_header.with(" ")
+        }
+
+        @objs.each {|o| 
+          r.table_row.with do 
+            if @edit == o
+
+              @attributes.each { |attr|
+                r.table_data.with { r.text_input.callback {|v| o.send(attr+"=",v) }.value(o.send(attr)) }
+              } 
+
+              r.table_data.with {
+                r.submit_button.callback { save(o) }.value("Save")
+                r.space
+                r.submit_button.callback { cancel() }.value("Cancel")
+                r.space
+                r.anchor.callback { delete(o) }.with("Delete")
+              }
+
+            else
+
+              @attributes.each { |attr|
+                r.table_data(o.send(attr))
+              } 
+
+              r.table_data.with {
+                r.anchor.callback { edit(o) }.with("Edit")
+                r.space
+                r.anchor.callback { delete(o) }.with("Delete")
+              }
+
+            end
+          end 
+        }
+      }
+    end
+
+    r.anchor.callback { create() }.with("Add new #{ @domain_class }")
+
+  end
+
+end
+

data/lib/wee/renderer/html/brushes.rb

@@ -47,47 +47,151 @@ class Brush::GenericEncodedTextBrush < Brush
   end
 end
 
+module Brush::ToCallback
+  private
+
+  def to_callback(symbol, args, block)
+    raise ArgumentError if symbol and block
+    if symbol
+      Wee::LiteralMethodCallback.new(@canvas.current_component, symbol, *args)
+    else
+      raise ArgumentError if not args.empty?
+      block
+    end
+  end
+end
+
 class Brush::GenericTagBrush < Brush
-  def initialize(tag)
-    super()
-    @tag = tag
-    @attributes = Hash.new
+
+  def self.bool_attr(*attrs)
+    attrs.each { |a|
+      class_eval " 
+        def #{ a }(bool=true)
+          if bool
+            @attributes['#{ a }'] = nil
+          else
+            @attributes.delete('#{ a }')
+          end
+          self
+        end
+      "
+    }
+  end
+
+  def self.html_attr(*attrs)
+    attrs.each { |a|
+      class_eval " 
+        def #{ a }(value)
+          html_attr('#{ a }', value)
+        end
+      "
+    }
   end
 
-  def type(t)
-    @attributes["type"] = t
+  private
+
+  def html_attr(attr, value)
+    if value.nil?
+      @attributes.delete(attr)
+    else
+      @attributes[attr] = value.to_s
+    end
     self
   end
 
+  public
+
+  def method_missing(id, attr)
+    html_attr(id.to_s, attr)
+  end
+
+  def initialize(tag, is_single_tag=false)
+    super()
+    @tag, @is_single_tag = tag, is_single_tag
+    @attributes = Hash.new
+  end
+
+  html_attr :type, :id
+
   def css_class(c)
-    @attributes["class"] = c
-    self
+    html_attr("class", c)
   end
 
-  def id(x)
-    @attributes["id"] = x
-    self
+  include Brush::ToCallback
+
+  def onclick_callback(symbol=nil, *args, &block)
+    raise ArgumentError if symbol and block
+    url = @canvas.url_for_callback(to_callback(symbol, args, block))
+    onclick("javascript: document.location.href='#{ url }';")          
   end
 
-  def method_missing(m, arg)
-    @attributes[m.to_s] = arg.to_s
-    self
+  # This method construct the css-class attribute by looking up the property
+  # from the current component.
+
+  def css_class_for(c)
+    prop = 'css.' + c
+    val = @canvas.current_component.lookup_property(prop)
+    raise "no property found for: <#{ prop }>" if val.nil?
+    css_class(val)
   end
 
   def with(text=nil, &block)
     doc = @canvas.document
-    doc.start_tag(@tag, @attributes)
-    if text
-      doc.text(text)
-      super(text, &block)
+    if @is_single_tag
+      raise ArgumentError if text or block
+      doc.single_tag(@tag, @attributes) 
+      @closed = true
     else
-      super(&block)
+      doc.start_tag(@tag, @attributes)
+      if text
+        doc.text(text)
+        super(text, &block)
+      else
+        super(&block)
+      end
+      doc.end_tag(@tag)
     end
-    doc.end_tag(@tag)
     nil
   end
 end
 
+class Brush::GenericSingleTagBrush < Brush::GenericTagBrush
+  def initialize(tag)
+    super(tag, true)
+  end
+end
+
+class Brush::ImageTag < Brush::GenericSingleTagBrush
+  html_attr :src
+
+  # This method construct the src attribute by looking up the property from the
+  # current component.
+
+  def src_for(s)
+    prop = "img." + s
+    val = @canvas.current_component.lookup_property(prop)
+    raise "no property found for: <#{ prop }>" if val.nil?
+    src(val)
+  end
+
+  def initialize
+    super("img")
+  end
+
+  def with
+    super
+  end
+end
+
+class Brush::JavascriptTag < Brush::GenericTagBrush
+  html_attr :src, :type
+
+  def initialize
+    super("script")
+    type("text/javascript")
+  end
+end
+
 class Brush::TableTag < Brush::GenericTagBrush
   def initialize
     super('table')
@@ -100,19 +204,34 @@ class Brush::TableRowTag < Brush::GenericTagBrush
   end
 
   def align_top
-    @attributes['align'] = 'top'
-    self
+    html_attr('align', 'top')
   end
 
-  def columns(*cols)
+  def columns(*cols, &block)
     with {
-      cols.each {|col| @canvas.table_data(col) }
+      cols.each {|col|
+        @canvas.table_data.with {
+          if block
+            block.call(col)
+          else
+            @canvas.text(col)
+          end
+        }
+      }
     } 
   end
 
-  def headings(*headers)
+  def headings(*headers, &block)
     with {
-      headers.each {|head| @canvas.table_heading(head) }
+      headers.each {|header|
+        @canvas.table_header.with {
+          if block
+            block.call(header)
+          else
+            @canvas.text(header)
+          end
+        }
+      }
     } 
   end
 
@@ -130,52 +249,52 @@ class Brush::TableRowTag < Brush::GenericTagBrush
 end
 
 
-class Brush::InputTag < Brush::GenericTagBrush
+class Brush::InputTag < Brush::GenericSingleTagBrush
   def initialize
     super('input')
   end
 
-  %w(type name value size maxlength checked src).each do |meth|
-    eval %[
-      def #{ meth }(arg)
-        @attributes['#{ meth }'] = arg
-        self
-      end
-    ]
-  end
+  html_attr :type, :name, :value, :size, :maxlength, :src
+  bool_attr :checked, :disabled, :readonly
 
   def with
     super
   end
 end
 
+
 module Brush::InputCallbackMixin
   public
 
-  def callback(symbol=nil, &block)
+  def callback(symbol=nil, *args, &block)
     raise ArgumentError if symbol and block
-    block = @canvas.current_component.method(symbol) unless block
-    name(@canvas.register_callback(:input, &block))
+    name(@canvas.register_callback(:input, to_callback(symbol, args, block)))
   end
+
+  include Brush::ToCallback 
 end
 
 module Brush::ActionCallbackMixin
   public
 
-  def callback(symbol=nil, &block)
+  def callback(symbol=nil, *args, &block)
     raise ArgumentError if symbol and block
-    block = @canvas.current_component.method(symbol) unless block
-    name(@canvas.register_callback(:action, &block))
+    name(@canvas.register_callback(:action, to_callback(symbol, args, block)))
   end
+
+  include Brush::ToCallback
 end
 
 # The callback id is listed in the URL (not as a form-data field)
 module Brush::ActionURLCallbackMixin
   public
 
-  def callback(symbol=nil, &block)
-    __set_url(@canvas.url_for_callback(symbol, &block))
+  def callback(symbol=nil, *args, &block)
+    raise ArgumentError if symbol and block
+    __set_url(@canvas.url_for_callback(to_callback(symbol, args, block)))
   end
+
+  include Brush::ToCallback
 end
 
 class Brush::TextAreaTag < Brush::GenericTagBrush
@@ -185,24 +304,8 @@ class Brush::TextAreaTag < Brush::GenericTagBrush
     super('textarea')
   end
 
-  %w(name rows cols tabindex accesskey onfocus onblur onselect onchange).each do |meth|
-    eval %[
-      def #{ meth }(arg)
-        @attributes['#{ meth }'] = arg
-        self
-      end
-    ]
-  end
-
-  def disabled
-    @attributes['disabled'] = nil 
-    self
-  end
-
-  def readonly
-    @attributes['readonly'] = nil 
-    self
-  end
+  html_attr :name, :rows, :cols, :tabindex, :accesskey, :onfocus, :onblur, :onselect, :onchange
+  bool_attr :disabled, :readonly
 
   def with(*args, &block)
     super
@@ -214,14 +317,7 @@ class Brush::SelectOptionTag < Brush::GenericTagBrush
     super('option')
   end
 
-  def selected(bool=true)
-    if bool
-      @attributes['selected'] = nil
-    else
-      @attributes.delete('selected')
-    end
-    self
-  end
+  bool_attr :selected
 end
 
 class Brush::SelectListTag < Brush::GenericTagBrush
@@ -241,17 +337,13 @@ class Brush::SelectListTag < Brush::GenericTagBrush
     ]
   end
 
-  def multiple
-    @multiple = true
-    @attributes['multiple'] = nil
-    self
-  end
+  bool_attr :multiple
 
   alias __old_callback callback
   private :__old_callback
   def callback(symbol=nil, &block)
     raise ArgumentError if symbol and block
-    block = @canvas.current_component.method(symbol) unless block
+    block = Wee::LiteralMethodCallback.new(@canvas.current_component, symbol) unless block
 
     @callback = block
     self
@@ -268,7 +360,9 @@ class Brush::SelectListTag < Brush::GenericTagBrush
           raise "invalid index in select list" if idx < 0 or idx > @items.size
           @items[idx]
         }
-        raise "choosen more than one element from a non-multiple select list" if not @multiple and choosen.size > 1
+        if choosen.size > 1 and not @attributes.has_key?('multiple')
+          raise "choosen more than one element from a non-multiple select list" 
+        end
         @callback.call(choosen)
       }
     end
@@ -277,7 +371,6 @@ class Brush::SelectListTag < Brush::GenericTagBrush
       @items.each_index do |i|
         @canvas.option.value(i).selected(@selected.include?(@items[i])).with(@labels[i])
       end
-      @canvas.text("")
     end
   end
 end
@@ -291,7 +384,7 @@ class Brush::TextInputTag < Brush::InputTag
   end
 end
 
-class Wee::Brush::FileUploadTag < Wee::Brush::InputTag
+class Brush::FileUploadTag < Brush::InputTag
   include Brush::InputCallbackMixin
 
   def initialize
@@ -318,7 +411,7 @@ end
 # #value method. Note that it's neccessary to parse the passed form-fields and
 # generate a "name" fields in the request, to make this image-button work. 
 
-class Wee::Brush::ImageButtonTag < Wee::Brush::InputTag
+class Brush::ImageButtonTag < Brush::InputTag
   include Brush::ActionCallbackMixin
 
   def initialize
@@ -338,8 +431,7 @@ class Brush::TableDataTag < Brush::GenericTagBrush
   end
 
   def align_top
-    @attributes['align'] = 'top'
-    self
+    html_attr('align', 'top')
   end
 end
 
@@ -358,15 +450,7 @@ class Brush::FormTag < Brush::GenericTagBrush
     @attributes['method'] = 'POST'
   end
 
-  def action(href)
-    @attributes['action'] = href 
-    self
-  end
-
-  def enctype(typ)
-    @attributes['enctype'] = typ
-    self
-  end
+  html_attr :action, :enctype
 
   alias __set_url action
 
@@ -387,19 +471,16 @@ class Brush::AnchorTag < Brush::GenericTagBrush
     super('a')
   end
 
-  def url(href)
-    @attributes['href'] = href 
-    self
-  end
-  alias href url
-
+  html_attr :href, :title
+  alias url href
+  alias tooltip title
   alias __set_url url
 end
 
 
 class Brush::Page < Brush
-  def title(str)
-    @title = str
+  def title(t)
+    @title = t
     self
   end