wee 0.7.0 → 0.8.0

data/ChangeLog

@@ -1,3 +1,99 @@
+Mon Apr  4 18:45:28 CET 2005	Michael Neumann <mneumann@ntecs.de>
+
+	* examples/ajax/ajax.rb, examples/ajax/ajax.js,
+	lib/wee/core/presenter.rb, lib/wee/renderer/html/brushes.rb: Added minimal
+	Ajax update support.
+
+Mon Apr  4 14:32:34 CET 2005	Michael Neumann <mneumann@ntecs.de>
+
+	* lib/wee/abstractsession.rb, lib/wee/session.rb,
+	  lib/wee/pageless/session.rb, examples/live-update.rb: refactored
+	  Session classes.
+
+	* lib/wee/core/presenter.rb: added send_response method, to send a
+	  premature response.
+
+Mon Apr  4 13:03:08 CET 2005	Michael Neumann <mneumann@ntecs.de>
+
+	* lib/wee/pageless/session.rb, lib/wee/pageless/application.rb: Remove
+	  dependency of WEBrick::Cookie, use CGI::Cookie instead.
+
+	* lib/wee/adaptors/fastcgi.rb: Added preliminary FastCGI adaptor
+	  (does not work yet with Pageless applications).
+
+	* lib/wee/adaptors/webrick.rb: reordered line
+
+Sun Apr  3 13:24:04 CET 2005	Michael Neumann <mneumann@ntecs.de>
+
+	* lib/wee/adaptors/webrick.rb: doc fix
+
+Sun Apr  3 13:11:07 CET 2005	Michael Neumann <mneumann@ntecs.de>
+
+	* lib/wee/core/presenter.rb, lib/wee/core/component.rb, 
+	  lib/wee/core/decoration.rb, lib/wee/session.rb, 
+	  lib/wee/pageless/session.rb, examples/window.rb, README:
+	  Fixed a bug in processing the callbacks. It was not guaranteed that
+	  all input callbacks are invoked before the final action callback.
+	  This is now guaranteed! I've introduced two separate tree traversals
+	  of process_callbacks to make this work. As a side effect, this also
+	  has removed the dependency of Presenter/Component/Decoration classes
+	  from the CallbackStream class. Instead of a CallbackStream, a code
+	  block is now passed through the
+	  process_callbacks/process_callbacks_chain traversal. The Session
+	  class specifies how to invoke the callbacks.
+
+Thu Mar  3 12:31:15 CET 2005	Michael Neumann <mneumann@ntecs.de>
+
+	* wee/session.rb, wee/pageless/session.rb: new methods 
+	  pre_respond_hook, post_callbacks_hook, especially to make pretty-URLs
+	  as suggested by Joao Pedrosa working.
+
+Thu Mar  3 12:11:05 CET 2005	Michael Neumann <mneumann@ntecs.de>
+
+	* wee/response.rb (Wee::Response): Use the passed mime_type as
+	  content-type (bug fix).
+
+	* wee/request.rb: Made 'info' attribute writeable.
+
+	* wee/core/callback.rb: Added reader method for 'obj'
+
+	* wee/core/component.rb: Added #parent method, to retrieve the parent
+	  component from a child if existent. The parent attribute will be set
+	  during #add_child.
+
+Thu Mar  3 11:38:21 CET 2005	Michael Neumann <mneumann@ntecs.de>
+
+	* wee/application.rb, wee/pageless/application.rb
+	  (request_handler_expired): Forward to an URL that includes the info
+	  part but neither the request_handler_id nor the page_id.
+
+Sat Feb 26 17:12:35 CET 2005	Michael Neumann <mneumann@ntecs.de>
+
+	* wee/request.rb, test/test_request.rb, wee/pageless/request.rb,
+	  wee/session.rb, wee/pageless/session.rb,
+	  wee/renderer/html/canvas.rb, wee/renderer/html/brushes.rb:
+
+	  - request delimeter changed to /___/ (looks nicer)
+
+	  - refactored Request#build_url, which now takes a hash and
+	    remembers already specified values
+
+	  - A Request knows now itself whether it's a action or a render 
+	    request.
+
+	  - added Request#info attribute. This is a part of the URL that you
+	    can use for your own purposes. It is remembered across requests
+	    unless you overwrite its value.
+
+Sat Feb 26 14:22:34 CET 2005	Michael Neumann	<mneumann@ntecs.de>
+
+	* wee/core/presenter.rb, wee/session.rb, wee/application.rb: renamed @properties to @__properties
+
+	* wee/core/component.rb: rename @children to @__children
+
+	* wee/core/component.rb, wee/core/valueholder.rb: rename @decoration
+	  to @__decoration
+
 --------------------------------------------------------------------
 TAGGED 0.7.0
 --------------------------------------------------------------------

data/README

@@ -237,11 +237,8 @@ called for the component itself.  As such, <i>process_callbacks_chain</i>
 is important to avoid entering an infinite loop (a method calling itself). What
 decorations are, is discussed elsewhere.
 
-Method <i>process_callbacks</i> of class Component first invokes all input
-callbacks specified for this component, then calls
-<i>process_callbacks_chain</i> for all of it's child components. This ensures,
-that all input callbacks are triggered before the first action callback is
-run. Finally, it invokes all of it's action callbacks.
+There are two "process_callbacks" tree traversals. The first invokes all input
+callbacks, the second the action callback.
 
 === Rendering Phase
 

data/examples/ObjectSpaceBrowser.rb

@@ -1,9 +1,8 @@
 $LOAD_PATH.unshift << "../lib"
 require 'wee'
-require 'wee/webrick'
-require 'wee/utils/cache'
+require 'wee/adaptors/webrick' 
+require 'wee/utils'
 require 'cgi'
-
 require 'enumerator'
 
 module ObjectSpaceBrowser
@@ -15,7 +14,7 @@ module ObjectSpaceBrowser
     end
 
     def choose(klass)
-      call(Klass.new(klass))
+      call Klass.new(klass)
     end
 
     def render
@@ -23,7 +22,7 @@ module ObjectSpaceBrowser
 
       r.ul {
         klasses.each do |klass|
-          r.li { r.anchor.action(:choose, klass).with(klass.name) }
+          r.li { r.anchor.callback(:choose, klass).with(klass.name) }
         end
       }
     end
@@ -63,7 +62,7 @@ module ObjectSpaceBrowser
 
       r.ul {
         @instances.each do |instance|
-          r.li { r.anchor.action(:choose, instance).with("0x%x" % instance.object_id) }
+          r.li { r.anchor.callback(:choose, instance).with("0x%x" % instance.object_id) }
         end
       }
     end
@@ -86,7 +85,7 @@ module ObjectSpaceBrowser
     end
 
     def render
-      r.anchor.action(:back).with("back")
+      r.anchor.callback(:back).with("back")
 
       r.break
       r.h1 "Instance 0x%x of #{@instance.class.name}" % @instance.object_id
@@ -97,7 +96,7 @@ module ObjectSpaceBrowser
         r.break
         r.ul do
           @instance.each do |obj|
-            r.li { render_obj(obj, r) }
+            r.li { render_obj(obj) }
           end
         end
       when Hash
@@ -111,8 +110,8 @@ module ObjectSpaceBrowser
 
           @instance.each_pair do |k, v|
             r.table_row do
-              r.table_data { render_obj(k, r) }
-              r.table_data { render_obj(v, r) }
+              r.table_data { render_obj(k) }
+              r.table_data { render_obj(v) }
             end
           end
         end
@@ -124,31 +123,31 @@ module ObjectSpaceBrowser
       return if @instance.instance_variables.empty?
       r.break
 
-      render_instance_variables(r)
+      render_instance_variables
     end
 
-    def render_instance_variables(r)
+    def render_instance_variables
       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(var, r) end
+        @instance.instance_variables.each do |var| render_ivar_row(var) end
       end
     end
 
-    def render_ivar_row(var, r)
+    def render_ivar_row(var)
       r.table_row do 
         r.table_data(var)
         r.table_data do
           v = @instance.instance_variable_get(var)
-          render_obj(v, r)
+          render_obj(v)
         end
       end
     end
 
-    def render_obj(obj, r)
-      r.anchor.action(:choose, obj).with do
+    def render_obj(obj)
+      r.anchor.callback(:choose, obj).with do
         r.bold(obj.class.name)
         r.space
         r.text("(#{ obj.object_id })")
@@ -170,30 +169,13 @@ 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 MySession < Wee::Session
-  def initialize
-    super do
-      self.root_component = ObjectSpaceBrowser::Instance.new(OBJ)
-      self.page_store = Wee::Utils::LRUCache.new(10) # backtrack up to 10 pages
-    end
-  end
-end
-
-class MyApplication < Wee::Application
-  def shutdown
-  end
-end
+  OBJ = {
+    "hello" => { [1,2,3] => [5,6,7], "test" => :super },
+    "other" => %w(a b c d e f)
+  }
 
-  Wee::Application.new {|app|
-    app.name = 'ObjectBrowser'
-    app.path = '/ob'
-    app.session_class = MySession
-    app.session_store = Wee::Utils::LRUCache.new(10)
-    app.dumpfile = ''
-  }.start
+  app = Wee::Utils.app_for {
+    ObjectSpaceBrowser::Instance.new(OBJ)
+  }
+  Wee::WEBrickAdaptor.register('/ob' => app).start 
 end

data/examples/ajax/ajax.js

@@ -0,0 +1,444 @@
+/*  Prototype: an object-oriented Javascript library, version 1.1.0
+ *  (c) 2005 Sam Stephenson <sam@conio.net>
+ *
+ *  Prototype is freely distributable under the terms of an MIT-style license. 
+ *  For details, see http://prototype.conio.net/
+ *
+ *  Changes by Michael Neumann.
+ */
+
+var Prototype = {
+  Version: '1.1.0'
+}
+
+var Class = {
+  create: function() {
+    return function() { 
+      this.initialize.apply(this, arguments);
+    }
+  }
+}
+
+var Abstract = new Object();
+
+Object.prototype.extend = function(object) {
+  for (property in object) {
+    this[property] = object[property];
+  }
+  return this;
+}
+
+Function.prototype.bind = function(object) {
+  var method = this;
+  return function() {
+    method.apply(object, arguments);
+  }
+}
+
+Function.prototype.bindAsEventListener = function(object) {
+  var method = this;
+  return function(event) {
+    method.call(object, event || window.event);
+  }
+}
+
+Number.prototype.toColorPart = function() {
+  var digits = this.toString(16);
+  if (this < 16) return '0' + digits;
+  return digits;
+}
+
+var Try = {
+  these: function() {
+    var returnValue;
+    
+    for (var i = 0; i < arguments.length; i++) {
+      var lambda = arguments[i];
+      try {
+        returnValue = lambda();
+        break;
+      } catch (e) {}
+    }
+    
+    return returnValue;
+  }
+}
+
+var Toggle = {
+  display: function() {
+    for (var i = 0; i < arguments.length; i++) {
+      var element = $(arguments[i]);
+      element.style.display = 
+        (element.style.display == 'none' ? '' : 'none');
+    }
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+
+function $() {
+  var elements = new Array();
+  
+  for (var i = 0; i < arguments.length; i++) {
+    var element = arguments[i];
+    if (typeof element == 'string')
+      element = document.getElementById(element);
+
+    if (arguments.length == 1) 
+      return element;
+      
+    elements.push(element);
+  }
+  
+  return elements;
+}
+
+function getElementsByClassName(className) {
+  var children = document.getElementsByTagName('*') || document.all;
+  var elements = new Array();
+  
+  for (var i = 0; i < children.length; i++) {
+    var child = children[i];
+    var classNames = child.className.split(' ');
+    for (var j = 0; j < classNames.length; j++) {
+      if (classNames[j] == className) {
+        elements.push(child);
+        break;
+      }
+    }
+  }
+  
+  return elements;
+}
+var Ajax = {
+  getTransport: function() {
+    return Try.these(
+      function() {return new ActiveXObject('Msxml2.XMLHTTP')},
+      function() {return new ActiveXObject('Microsoft.XMLHTTP')},
+      function() {return new XMLHttpRequest()}
+    ) || false;
+  },
+  
+  emptyFunction: function() {}
+}
+
+Ajax.Base = function() {};
+Ajax.Base.prototype = {
+  setOptions: function(options) {
+    this.options = {
+      method:       'post',
+      asynchronous: true,
+      parameters:   ''
+    }.extend(options || {});
+  }
+}
+
+Ajax.Request = Class.create();
+Ajax.Request.Events = 
+  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
+
+Ajax.Request.prototype = (new Ajax.Base()).extend({
+  initialize: function(url, options) {
+    this.transport = Ajax.getTransport();
+    this.setOptions(options);
+  
+    try {
+      /*if (this.options.method == 'get')
+        url += '?' + this.options.parameters; */
+    
+      this.transport.open(this.options.method, url, true);
+      
+      if (this.options.asynchronous) {
+        this.transport.onreadystatechange = this.onStateChange.bind(this);
+        setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);
+      }
+              
+      if (this.options.method == 'post') {
+        this.transport.setRequestHeader('Connection', 'close');
+        this.transport.setRequestHeader('Content-type',
+          'application/x-www-form-urlencoded');
+      }
+      
+      this.transport.send(this.options.method == 'post' ? 
+        this.options.parameters : null);
+                      
+    } catch (e) {
+    }    
+  },
+      
+  onStateChange: function() {
+    var readyState = this.transport.readyState;
+    if (readyState != 1)
+      this.respondToReadyState(this.transport.readyState);
+  },
+  
+  respondToReadyState: function(readyState) {
+    var event = Ajax.Request.Events[readyState];
+    (this.options['on' + event] || Ajax.emptyFunction)(this.transport);
+  }
+});
+
+Ajax.Updater = Class.create();
+Ajax.Updater.prototype = (new Ajax.Base()).extend({
+  initialize: function(container, url, options) {
+    this.container = $(container);
+    this.setOptions(options);
+  
+    if (this.options.asynchronous) {
+      this.onComplete = this.options.onComplete;
+      this.options.onComplete = this.updateContent.bind(this);
+    }
+    
+    this.request = new Ajax.Request(url, this.options);
+    
+    if (!this.options.asynchronous)
+      this.updateContent();
+  },
+  
+  updateContent: function() {
+    if (this.options.insertion) {
+      new this.options.insertion(this.container,
+        this.request.transport.responseText);
+    } else {
+      this.container.innerHTML = this.request.transport.responseText;
+    }
+
+    if (this.onComplete) {
+      setTimeout((function() {this.onComplete(this.request)}).bind(this), 10);
+    }
+  }
+});
+var Field = {
+  clear: function() {
+    for (var i = 0; i < arguments.length; i++)
+      $(arguments[i]).value = '';
+  },
+
+  focus: function(element) {
+    $(element).focus();
+  },
+  
+  present: function() {
+    for (var i = 0; i < arguments.length; i++)
+      if ($(arguments[i]).value == '') return false;
+    return true;
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+
+var Form = {
+  serialize: function(form) {
+    var elements = Form.getElements($(form));
+    var queryComponents = new Array();
+    
+    for (var i = 0; i < elements.length; i++) {
+      var queryComponent = Form.Element.serialize(elements[i]);
+      if (queryComponent)
+        queryComponents.push(queryComponent);
+    }
+    
+    return queryComponents.join('&');
+  },
+  
+  getElements: function(form) {
+    form = $(form);
+    var elements = new Array();
+
+    for (tagName in Form.Element.Serializers) {
+      var tagElements = form.getElementsByTagName(tagName);
+      for (var j = 0; j < tagElements.length; j++)
+        elements.push(tagElements[j]);
+    }
+    return elements;
+  }
+}
+
+Form.Element = {
+  serialize: function(element) {
+    element = $(element);
+    var method = element.tagName.toLowerCase();
+    var parameter = Form.Element.Serializers[method](element);
+    
+    if (parameter)
+      return encodeURIComponent(parameter[0]) + '=' + 
+        encodeURIComponent(parameter[1]);                   
+  },
+  
+  getValue: function(element) {
+    element = $(element);
+    var method = element.tagName.toLowerCase();
+    var parameter = Form.Element.Serializers[method](element);
+    
+    if (parameter) 
+      return parameter[1];
+  }
+}
+
+Form.Element.Serializers = {
+  input: function(element) {
+    switch (element.type.toLowerCase()) {
+      case 'hidden':
+      case 'password':
+      case 'text':
+        return Form.Element.Serializers.textarea(element);
+      case 'checkbox':  
+      case 'radio':
+        return Form.Element.Serializers.inputSelector(element);
+    }
+    return false;
+  },
+
+  inputSelector: function(element) {
+    if (element.checked)
+      return [element.name, element.value];
+  },
+
+  textarea: function(element) {
+    return [element.name, element.value];
+  },
+
+  select: function(element) {
+    var index = element.selectedIndex;
+    return [element.name, (index >= 0) ? element.options[index].value : ''];
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+
+Abstract.TimedObserver = function() {}
+Abstract.TimedObserver.prototype = {
+  initialize: function(element, frequency, callback) {
+    this.frequency = frequency;
+    this.element   = $(element);
+    this.callback  = callback;
+    
+    this.lastValue = this.getValue();
+    this.registerCallback();
+  },
+  
+  registerCallback: function() {
+    setTimeout(this.onTimerEvent.bind(this), this.frequency * 1000);
+  },
+  
+  onTimerEvent: function() {
+    var value = this.getValue();
+    if (this.lastValue != value) {
+      this.callback(this.element, value);
+      this.lastValue = value;
+    }
+    
+    this.registerCallback();
+  }
+}
+
+Form.Element.Observer = Class.create();
+Form.Element.Observer.prototype = (new Abstract.TimedObserver()).extend({
+  getValue: function() {
+    return Form.Element.getValue(this.element);
+  }
+});
+
+Form.Observer = Class.create();
+Form.Observer.prototype = (new Abstract.TimedObserver()).extend({
+  getValue: function() {
+    return Form.serialize(this.element);
+  }
+});
+
+Abstract.Insertion = function(adjacency) {
+  this.adjacency = adjacency;
+}
+
+Abstract.Insertion.prototype = {
+  initialize: function(element, content) {
+    this.element = $(element);
+    this.content = content;
+    
+    if (this.adjacency && this.element.insertAdjacentHTML) {
+      this.element.insertAdjacentHTML(this.adjacency, this.content);
+    } else {
+      this.range = this.element.ownerDocument.createRange();
+      if (this.initializeRange) this.initializeRange();
+      this.fragment = this.range.createContextualFragment(this.content);
+      this.insertContent();
+    }
+  }
+}
+
+var Insertion = new Object();
+
+Insertion.Before = Class.create();
+Insertion.Before.prototype = (new Abstract.Insertion('beforeBegin')).extend({
+  initializeRange: function() {
+    this.range.setStartBefore(this.element);
+  },
+  
+  insertContent: function() {
+    this.element.parentNode.insertBefore(this.fragment, this.element);
+  }
+});
+
+Insertion.Top = Class.create();
+Insertion.Top.prototype = (new Abstract.Insertion('afterBegin')).extend({
+  initializeRange: function() {
+    this.range.selectNodeContents(this.element);
+    this.range.collapse(true);
+  },
+  
+  insertContent: function() {  
+    this.element.insertBefore(this.fragment, this.element.firstChild);
+  }
+});
+
+Insertion.Bottom = Class.create();
+Insertion.Bottom.prototype = (new Abstract.Insertion('beforeEnd')).extend({
+  initializeRange: function() {
+    this.range.selectNodeContents(this.element);
+    this.range.collapse(this.element);
+  },
+  
+  insertContent: function() {
+    this.element.appendChild(this.fragment);
+  }
+});
+
+Insertion.After = Class.create();
+Insertion.After.prototype = (new Abstract.Insertion('afterEnd')).extend({
+  initializeRange: function() {
+    this.range.setStartAfter(this.element);
+  },
+  
+  insertContent: function() {
+    this.element.parentNode.insertBefore(this.fragment, 
+      this.element.nextSibling);
+  }
+});
+var Effect = new Object();
+
+Effect.Highlight = Class.create();
+Effect.Highlight.prototype = {
+  initialize: function(element) {
+    this.element = $(element);
+    this.start  = 153;
+    this.finish = 255;
+    this.current = this.start;
+    this.fade();
+  },
+  
+  fade: function() {
+    if (this.isFinished()) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.highlight(this.element, this.current);
+    this.current += 17;
+    this.timer = setTimeout(this.fade.bind(this), 250);
+  },
+  
+  isFinished: function() {
+    return this.current > this.finish;
+  },
+  
+  highlight: function(element, current) {
+    element.style.backgroundColor = "#ffff" + current.toColorPart();
+  }
+}