nitro 0.29.0 → 0.30.0

data/lib/nitro/server.rb

@@ -88,16 +88,6 @@ class Server
     @map['/'] = options[:controller] if options[:controller]
     @dispatcher = options[:dispatcher] || Dispatcher.new(@map)
 
-    # Create the actual store. Copy values already inserted
-    # in the temporary cache.
-    #--
-    # FIXME: cleanup this code
-    #++
-    
-    temp = $global
-    $global = $application = Context.global_cache_class.new
-    $global.update(temp)
-
     return self
   end
 
@@ -128,6 +118,10 @@ class Server
     runner.setup_mode
     runner.daemonize if runner.daemon  
 
+    unless Session.cache
+      require 'nitro/session/memory'
+    end
+    
     server = Server.new
     server.start(options)
      

data/lib/nitro/server/drb.rb

@@ -68,7 +68,7 @@ class DrbServer
   # The default implementation only creates a session store.
   
   def setup_drb_objects
-    require 'nitro/session'
+    require 'nitro/session/drb'
     @session_cache = SyncHash.new 
     DRb.start_service("druby://#{Session.cache_address}:#{Session.cache_port}", @session_cache)    
     puts "Drb session cache at druby://#{Session.cache_address}:#{Session.cache_port}."

data/lib/nitro/server/runner.rb

@@ -189,6 +189,16 @@ class Runner
         @spider = :render
       end
 
+      opts.on('--record FILENAME', 'Record the application server session to the given file.') do |filename|
+        @server = :webrick
+        $record_session_filename = filename || 'vcrsession.yaml'
+      end
+
+      opts.on('--playback FILENAME', 'Playback a previously recorded session from the given file.') do |filename|
+        @server = :webrick
+        $playback_session_filename = filename || 'vcrsession.yaml'
+      end
+
       opts.on_tail('-v', '--version', 'Show version.') do 
         puts "Nitro #{Nitro::Version}"
         exit

data/lib/nitro/session.rb

@@ -1,13 +1,13 @@
 require 'md5'
 require 'webrick'
 
-require 'facet/synchash'
-require 'facet/times'
+require 'facets/more/synchash'
+require 'facets/more/times'
+require 'facets/more/expirable'
 
 require 'glue'
 require 'glue/attribute'
 require 'glue/configuration'
-require 'glue/expirable'
 
 require 'nitro/cgi/cookie'
 
@@ -24,13 +24,19 @@ module Nitro
 # The session should be persistable to survive server 
 # shutdowns.
 #
+# The session can be considered as a Hash where key-value
+# pairs are stored. Typically symbols are used as keys. By
+# convention uppercase symbols are used for internal Nitro
+# session variables (ie :FLASH, :USER, etc). User applications
+# typically use lowercase symbols (ie :cart, :history, etc).
+#
 #--
 # TODO: rehash of the session cookie
 # TODO: store -> cache, reimplement helpers.
 #++
 
 class Session < Hash
-  include Glue::Expirable
+  include Expirable
 
   # Session id salt.
 
@@ -99,15 +105,28 @@ class Session < Hash
       return session
     end
 
+    # The number of active (online) sessions.
+    # DON'T use yet!
+    
+    def count
+      Session.cache.size
+    end
+    
+    # Perform Session garbage collection. You may call this 
+    # method from a cron job.
+    
+    def garbage_collect
+      expired = []
+      for s in Session.cache.all
+        expired << s.session_id if s.expired?
+      end
+      for sid in expired
+        Session.cache.delete(sid)
+      end
+    end
+    alias_method :gc!, :garbage_collect
   end
 
-  # By default sessions are stored in memory.
-  #--
-  # gmosx: should be placed here.
-  #++
-  
-  set_cache_type(:memory)  
-
   # The unique id of this session.
 
   attr_reader :session_id
@@ -145,7 +164,7 @@ protected
   # Random may produce equal ids? add a prefix 
   # (SALT) to stop hackers from creating session_ids.
   #--
-  # THINK: Is MD5 slow???
+  # THINK: Is MD5 slow??? Allow for pluggable hashes.
   #++
   
   def create_id

data/lib/nitro/session/drb.rb

@@ -3,7 +3,19 @@ require 'nitro/session'
 
 module Nitro
 
-Logger.debug "Using DRb sessions at #{Glue::DrbCache.address}:#{Glue::DrbCache.port}." if defined?(Logger)
+Logger.info "Using DRb sessions at #{Glue::DrbCache.address}:#{Glue::DrbCache.port}." if defined?(Logger) && $DBG
+
+class Session < Hash
+  
+  # The address of the Drb store.
+  
+  setting :cache_address, :default => '127.0.0.1', :doc => 'The address of the Drb store'
+
+  # The port of the Drb store.
+  
+  setting :cache_port, :default => 9069, :doc => 'The port of the Drb store'
+
+end
 
 Session.cache = Glue::DrbCache.new
 

data/lib/nitro/session/file.rb

@@ -5,7 +5,7 @@ module Nitro
   
 # A Session manager that persists sessions on disk.
 
-Logger.debug "Using File sessions." if defined?(Logger)
+Logger.info "Using File sessions." if defined?(Logger) && $DBG
 
 Session.cache = Glue::FileCache.new("session_#{Session.cookie_name}", Session.keepalive)
 

data/lib/nitro/session/memcached.rb

@@ -5,7 +5,7 @@ module Nitro
   
 # A Session manager that persists sessions on disk.
 
-Logger.debug "Using MemCached sessions." if defined?(Logger)
+Logger.debug "Using MemCached sessions." if defined?(Logger) && $DBG
 
 Session.cache = Glue::MemCached.new("session_#{Session.cookie_name}", Session.keepalive)
 

data/lib/nitro/session/memory.rb

@@ -4,7 +4,7 @@ require 'glue/logger'
 
 module Nitro
 
-Logger.debug "Using Memory sessions." if defined?(Logger)
+Logger.info "Using Memory sessions." if defined?(Logger) && $DBG
 
 Session.cache = Glue::MemoryCache.new
 

data/lib/nitro/session/og.rb

@@ -5,7 +5,7 @@ module Nitro
 
 # A Session manager that persists sessions on an Og store.
 
-Logger.debug "Using Og sessions." if defined?(Logger)
+Logger.debug "Using Og sessions." if defined?(Logger) && $DBG
 
 Session.cache = OgCache.new("session_#{Session.cookie_name}", Session.keepalive)
 

data/lib/nitro/test/testcase.rb

@@ -44,6 +44,9 @@ class TestCase
     context.headers['REQUEST_URI'] = uri
     context.headers['REQUEST_METHOD'] = options[:method].to_s.upcase
     context.headers['REMOTE_ADDR'] ||= '127.0.0.1'
+    if ((:get == options[:method]) and (options[:params]))
+      context.headers['QUERY_STRING'] = options[:params].collect {|k,v| "#{k}=#{v}"}.join('&')
+    end
     context.cookies.merge! options[:cookies] if options[:cookies]
     context.session.merge! options[:session] if options[:session]
     

data/proto/public/error.xhtml

@@ -1,7 +1,7 @@
 <html>
   <head>
     <script lang="javascript" type="text/javascript">
-  // <!--
+    // <!--
     function toggleVisible(element) {
       if (element.style.display == 'block') {
         element.style.display = 'none';
@@ -98,26 +98,26 @@
       </div>
     <?r end ?>
 
-    <h2><a href="#" onclick="document.getElementById('request').style.display = 'block'; return false">Request</a></h2>
+    <h2><a href="#" onclick="return toggleVisible(document.getElementById('request'));">Request</a></h2>
     <div id="request" style="display: none">
       <p><strong>Parameters:</strong> #{request.params.reject{ |k,v| k == :__RELOADED__ }.inspect}</p>  
       <p><strong>Cookies:</strong> #{request.cookies.inspect}</p>  
       <p><strong>Headers:</strong><br />#{request.headers.collect { |k, v| "#{k} => #{v}" }.join('<br />')}</p>  
     </div>
 
-    <h2><a href="#" onclick="document.getElementById('response').style.display = 'block'; return false">Response</a></h2>
+    <h2><a href="#" onclick="return toggleVisible(document.getElementById('response'));">Response</a></h2>
     <div id="response" style="display: none">
       <p><strong>Headers:</strong> #{request.response_headers.inspect}</p>  
       <p><strong>Cookies:</strong> #{request.response_cookies.inspect}</p>  
     </div>
 
-    <h2><a href="#" onclick="document.getElementById('session').style.display = 'block'; return false">Session</a></h2>
+    <h2><a href="#" onclick="return toggleVisible(document.getElementById('session'));">Session</a></h2>
     <div id="session" style="display: none">
       <p><strong>Values:</strong> #{session.inspect}</p>  
     </div>
 
     <br /><br />
-    Powered by <a href="http://www.nitrohq.com">Nitro</a> version #{Nitro::Version}
+    Powered by <a href="http://www.nitroproject.org">Nitro</a> version #{Nitro::Version}
 <?r end ?>    
   </body>
 </html>

data/proto/public/js/controls.js

@@ -141,8 +141,8 @@ Autocompleter.Base.prototype = {
          return;
       }
      else 
-      if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN) 
-        return;
+       if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN || 
+         (navigator.appVersion.indexOf('AppleWebKit') > 0 && event.keyCode == 0)) return;
 
     this.changed = true;
     this.hasFocus = true;

data/proto/public/js/dragdrop.js

@@ -1,4 +1,5 @@
 // Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+//           (c) 2005 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
 // 
 // See scriptaculous.js for full license.
 
@@ -15,7 +16,8 @@ var Droppables = {
     element = $(element);
     var options = Object.extend({
       greedy:     true,
-      hoverclass: null  
+      hoverclass: null,
+      tree:       false
     }, arguments[1] || {});
 
     // cache containers
@@ -37,12 +39,27 @@ var Droppables = {
 
     this.drops.push(options);
   },
+  
+  findDeepestChild: function(drops) {
+    deepest = drops[0];
+      
+    for (i = 1; i < drops.length; ++i)
+      if (Element.isParent(drops[i].element, deepest.element))
+        deepest = drops[i];
+    
+    return deepest;
+  },
 
   isContained: function(element, drop) {
-    var parentNode = element.parentNode;
-    return drop._containers.detect(function(c) { return parentNode == c });
+    var containmentNode;
+    if(drop.tree) {
+      containmentNode = element.treeNode; 
+    } else {
+      containmentNode = element.parentNode;
+    }
+    return drop._containers.detect(function(c) { return containmentNode == c });
   },
-
+  
   isAffected: function(point, element, drop) {
     return (
       (drop.element!=element) &&
@@ -68,18 +85,22 @@ var Droppables = {
 
   show: function(point, element) {
     if(!this.drops.length) return;
+    var affected = [];
     
     if(this.last_active) this.deactivate(this.last_active);
     this.drops.each( function(drop) {
-      if(Droppables.isAffected(point, element, drop)) {
-        if(drop.onHover)
-           drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
-        if(drop.greedy) { 
-          Droppables.activate(drop);
-          throw $break;
-        }
-      }
+      if(Droppables.isAffected(point, element, drop))
+        affected.push(drop);
     });
+        
+    if(affected.length>0) {
+      drop = Droppables.findDeepestChild(affected);
+      Position.within(drop.element, point[0], point[1]);
+      if(drop.onHover)
+        drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
+      
+      Droppables.activate(drop);
+    }
   },
 
   fire: function(event, element) {
@@ -187,15 +208,17 @@ Draggable.prototype = {
   initialize: function(element) {
     var options = Object.extend({
       handle: false,
-      starteffect: function(element) { 
-        new Effect.Opacity(element, {duration:0.2, from:1.0, to:0.7}); 
+      starteffect: function(element) {
+        element._opacity = Element.getOpacity(element); 
+        new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7}); 
       },
       reverteffect: function(element, top_offset, left_offset) {
         var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
         element._revert = new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur});
       },
-      endeffect: function(element) { 
-        new Effect.Opacity(element, {duration:0.2, from:0.7, to:1.0}); 
+      endeffect: function(element) {
+        var toOpacity = typeof element._opacity == 'number' ? element._opacity : 1.0
+        new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity}); 
       },
       zindex: 1000,
       revert: false,
@@ -207,12 +230,15 @@ Draggable.prototype = {
 
     this.element = $(element);
     
-    if(options.handle && (typeof options.handle == 'string'))
-      this.handle = Element.childrenWithClassName(this.element, options.handle)[0];  
+    if(options.handle && (typeof options.handle == 'string')) {
+      var h = Element.childrenWithClassName(this.element, options.handle, true);
+      if(h.length>0) this.handle = h[0];
+    }
     if(!this.handle) this.handle = $(options.handle);
     if(!this.handle) this.handle = this.element;
     
-    if(options.scroll) options.scroll = $(options.scroll);
+    if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML)
+      options.scroll = $(options.scroll);
 
     Element.makePositioned(this.element); // fix IE    
 
@@ -277,8 +303,14 @@ Draggable.prototype = {
     }
     
     if(this.options.scroll) {
-      this.originalScrollLeft = this.options.scroll.scrollLeft;
-      this.originalScrollTop = this.options.scroll.scrollTop;
+      if (this.options.scroll == window) {
+        var where = this._getWindowScroll(this.options.scroll);
+        this.originalScrollLeft = where.left;
+        this.originalScrollTop = where.top;
+      } else {
+        this.originalScrollLeft = this.options.scroll.scrollLeft;
+        this.originalScrollTop = this.options.scroll.scrollTop;
+      }
     }
     
     Draggables.notify('onStart', this, event);
@@ -294,13 +326,18 @@ Draggable.prototype = {
     if(this.options.change) this.options.change(this);
     
     if(this.options.scroll) {
-      //if(this.scrollInterval) this.scroll();
       this.stopScrolling();
-      var p = Position.page(this.options.scroll);
-      p[0] += this.options.scroll.scrollLeft;
-      p[1] += this.options.scroll.scrollTop;
-      p.push(p[0]+this.options.scroll.offsetWidth);
-      p.push(p[1]+this.options.scroll.offsetHeight);
+      
+      var p;
+      if (this.options.scroll == window) {
+        with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
+      } else {
+        p = Position.page(this.options.scroll);
+        p[0] += this.options.scroll.scrollLeft;
+        p[1] += this.options.scroll.scrollTop;
+        p.push(p[0]+this.options.scroll.offsetWidth);
+        p.push(p[1]+this.options.scroll.offsetHeight);
+      }
       var speed = [0,0];
       if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
       if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
@@ -366,7 +403,7 @@ Draggable.prototype = {
     var d = this.currentDelta();
     pos[0] -= d[0]; pos[1] -= d[1];
     
-    if(this.options.scroll) {
+    if(this.options.scroll && (this.options.scroll != window)) {
       pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
       pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
     }
@@ -377,7 +414,7 @@ Draggable.prototype = {
     
     if(this.options.snap) {
       if(typeof this.options.snap == 'function') {
-        p = this.options.snap(p[0],p[1]);
+        p = this.options.snap(p[0],p[1],this);
       } else {
       if(this.options.snap instanceof Array) {
         p = p.map( function(v, i) {
@@ -400,6 +437,7 @@ Draggable.prototype = {
     if(this.scrollInterval) {
       clearInterval(this.scrollInterval);
       this.scrollInterval = null;
+      Draggables._lastScrollPointer = null;
     }
   },
   
@@ -413,15 +451,55 @@ Draggable.prototype = {
     var current = new Date();
     var delta = current - this.lastScrolled;
     this.lastScrolled = current;
-    this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
-    this.options.scroll.scrollTop  += this.scrollSpeed[1] * delta / 1000;
+    if(this.options.scroll == window) {
+      with (this._getWindowScroll(this.options.scroll)) {
+        if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
+          var d = delta / 1000;
+          this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
+        }
+      }
+    } else {
+      this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
+      this.options.scroll.scrollTop  += this.scrollSpeed[1] * delta / 1000;
+    }
     
     Position.prepare();
     Droppables.show(Draggables._lastPointer, this.element);
     Draggables.notify('onDrag', this);
-    this.draw(Draggables._lastPointer);    
+    Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
+    Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
+    Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
+    if (Draggables._lastScrollPointer[0] < 0)
+      Draggables._lastScrollPointer[0] = 0;
+    if (Draggables._lastScrollPointer[1] < 0)
+      Draggables._lastScrollPointer[1] = 0;
+    this.draw(Draggables._lastScrollPointer);
     
     if(this.options.change) this.options.change(this);
+  },
+  
+  _getWindowScroll: function(w) {
+    var T, L, W, H;
+    with (w.document) {
+      if (w.document.documentElement && documentElement.scrollTop) {
+        T = documentElement.scrollTop;
+        L = documentElement.scrollLeft;
+      } else if (w.document.body) {
+        T = body.scrollTop;
+        L = body.scrollLeft;
+      }
+      if (w.innerWidth) {
+        W = w.innerWidth;
+        H = w.innerHeight;
+      } else if (w.document.documentElement && documentElement.clientWidth) {
+        W = documentElement.clientWidth;
+        H = documentElement.clientHeight;
+      } else {
+        W = body.offsetWidth;
+        H = body.offsetHeight
+      }
+    }
+    return { top: T, left: L, width: W, height: H };
   }
 }
 
@@ -447,30 +525,41 @@ SortableObserver.prototype = {
 }
 
 var Sortable = {
-  sortables: new Array(),
+  sortables: {},
   
-  options: function(element){
-    element = $(element);
-    return this.sortables.detect(function(s) { return s.element == element });
+  _findRootElement: function(element) {
+    while (element.tagName != "BODY") {  
+      if(element.id && Sortable.sortables[element.id]) return element;
+      element = element.parentNode;
+    }
+  },
+
+  options: function(element) {
+    element = Sortable._findRootElement($(element));
+    if(!element) return;
+    return Sortable.sortables[element.id];
   },
   
   destroy: function(element){
-    element = $(element);
-    this.sortables.findAll(function(s) { return s.element == element }).each(function(s){
+    var s = Sortable.options(element);
+    
+    if(s) {
       Draggables.removeObserver(s.element);
       s.droppables.each(function(d){ Droppables.remove(d) });
       s.draggables.invoke('destroy');
-    });
-    this.sortables = this.sortables.reject(function(s) { return s.element == element });
+      
+      delete Sortable.sortables[s.element.id];
+    }
   },
-  
+
   create: function(element) {
     element = $(element);
     var options = Object.extend({ 
       element:     element,
       tag:         'li',       // assumes li children, override with tag: 'tagname'
       dropOnEmpty: false,
-      tree:        false,      // fixme: unimplemented
+      tree:        false,
+      treeTag:     'ul',
       overlap:     'vertical', // one of 'vertical', 'horizontal'
       constraint:  'vertical', // one of 'vertical', 'horizontal', false
       containment: element,    // also takes array of elements (or id's); or false
@@ -479,6 +568,8 @@ var Sortable = {
       hoverclass:  null,
       ghosting:    false,
       scroll:      false,
+      scrollSensitivity: 20,
+      scrollSpeed: 15,
       format:      /^[^_]*_(.*)$/,
       onChange:    Prototype.emptyFunction,
       onUpdate:    Prototype.emptyFunction
@@ -491,6 +582,8 @@ var Sortable = {
     var options_for_draggable = {
       revert:      true,
       scroll:      options.scroll,
+      scrollSpeed: options.scrollSpeed,
+      scrollSensitivity: options.scrollSensitivity,
       ghosting:    options.ghosting,
       constraint:  options.constraint,
       handle:      options.handle };
@@ -516,9 +609,17 @@ var Sortable = {
     var options_for_droppable = {
       overlap:     options.overlap,
       containment: options.containment,
+      tree:        options.tree,
       hoverclass:  options.hoverclass,
-      onHover:     Sortable.onHover,
-      greedy:      !options.dropOnEmpty
+      onHover:     Sortable.onHover
+      //greedy:      !options.dropOnEmpty
+    }
+    
+    var options_for_tree = {
+      onHover:      Sortable.onEmptyHover,
+      overlap:      options.overlap,
+      containment:  options.containment,
+      hoverclass:   options.hoverclass
     }
 
     // fix for gecko engine
@@ -527,12 +628,9 @@ var Sortable = {
     options.draggables = [];
     options.droppables = [];
 
-    // make it so
-
     // drop on empty handling
-    if(options.dropOnEmpty) {
-      Droppables.add(element,
-        {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false});
+    if(options.dropOnEmpty || options.tree) {
+      Droppables.add(element, options_for_tree);
       options.droppables.push(element);
     }
 
@@ -543,11 +641,20 @@ var Sortable = {
       options.draggables.push(
         new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
       Droppables.add(e, options_for_droppable);
+      if(options.tree) e.treeNode = element;
       options.droppables.push(e);      
     });
+    
+    if(options.tree) {
+      (Sortable.findTreeElements(element, options) || []).each( function(e) {
+        Droppables.add(e, options_for_tree);
+        e.treeNode = element;
+        options.droppables.push(e);
+      });
+    }
 
     // keep reference
-    this.sortables.push(options);
+    this.sortables[element.id] = options;
 
     // for onupdate
     Draggables.addObserver(new SortableObserver(element, options.onUpdate));
@@ -556,23 +663,21 @@ var Sortable = {
 
   // return all suitable-for-sortable elements in a guaranteed order
   findElements: function(element, options) {
-    if(!element.hasChildNodes()) return null;
-    var elements = [];
-    $A(element.childNodes).each( function(e) {
-      if(e.tagName && e.tagName.toUpperCase()==options.tag.toUpperCase() &&
-        (!options.only || (Element.hasClassName(e, options.only))))
-          elements.push(e);
-      if(options.tree) {
-        var grandchildren = this.findElements(e, options);
-        if(grandchildren) elements.push(grandchildren);
-      }
-    });
-
-    return (elements.length>0 ? elements.flatten() : null);
+    return Element.findChildren(
+      element, options.only, options.tree ? true : false, options.tag);
+  },
+  
+  findTreeElements: function(element, options) {
+    return Element.findChildren(
+      element, options.only, options.tree ? true : false, options.treeTag);
   },
 
   onHover: function(element, dropon, overlap) {
-    if(overlap>0.5) {
+    if(Element.isParent(dropon, element)) return;
+
+    if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
+      return;
+    } else if(overlap>0.5) {
       Sortable.mark(dropon, 'before');
       if(dropon.previousSibling != element) {
         var oldParentNode = element.parentNode;
@@ -595,13 +700,37 @@ var Sortable = {
       }
     }
   },
-
-  onEmptyHover: function(element, dropon) {
-    if(element.parentNode!=dropon) {
-      var oldParentNode = element.parentNode;
-      dropon.appendChild(element);
+  
+  onEmptyHover: function(element, dropon, overlap) {
+    var oldParentNode = element.parentNode;
+    var droponOptions = Sortable.options(dropon);
+        
+    if(!Element.isParent(dropon, element)) {
+      var index;
+      
+      var children = Sortable.findElements(dropon, {tag: droponOptions.tag});
+      var child = null;
+            
+      if(children) {
+        var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
+        
+        for (index = 0; index < children.length; index += 1) {
+          if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
+            offset -= Element.offsetSize (children[index], droponOptions.overlap);
+          } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
+            child = index + 1 < children.length ? children[index + 1] : null;
+            break;
+          } else {
+            child = children[index];
+            break;
+          }
+        }
+      }
+      
+      dropon.insertBefore(element, child);
+      
       Sortable.options(oldParentNode).onChange(element);
-      Sortable.options(dropon).onChange(element);
+      droponOptions.onChange(element);
     }
   },
 
@@ -633,6 +762,75 @@ var Sortable = {
     
     Element.show(Sortable._marker);
   },
+  
+  _tree: function(element, options, parent) {
+    var children = Sortable.findElements(element, options) || [];
+  
+    for (var i = 0; i < children.length; ++i) {
+      var match = children[i].id.match(options.format);
+
+      if (!match) continue;
+      
+      var child = {
+        id: encodeURIComponent(match ? match[1] : null),
+        element: element,
+        parent: parent,
+        children: new Array,
+        position: parent.children.length,
+        container: Sortable._findChildrenElement(children[i], options.treeTag.toUpperCase())
+      }
+      
+      /* Get the element containing the children and recurse over it */
+      if (child.container)
+        this._tree(child.container, options, child)
+      
+      parent.children.push (child);
+    }
+
+    return parent; 
+  },
+
+  /* Finds the first element of the given tag type within a parent element.
+    Used for finding the first LI[ST] within a L[IST]I[TEM].*/
+  _findChildrenElement: function (element, containerTag) {
+    if (element && element.hasChildNodes)
+      for (var i = 0; i < element.childNodes.length; ++i)
+        if (element.childNodes[i].tagName == containerTag)
+          return element.childNodes[i];
+  
+    return null;
+  },
+
+  tree: function(element) {
+    element = $(element);
+    var sortableOptions = this.options(element);
+    var options = Object.extend({
+      tag: sortableOptions.tag,
+      treeTag: sortableOptions.treeTag,
+      only: sortableOptions.only,
+      name: element.id,
+      format: sortableOptions.format
+    }, arguments[1] || {});
+    
+    var root = {
+      id: null,
+      parent: null,
+      children: new Array,
+      container: element,
+      position: 0
+    }
+    
+    return Sortable._tree (element, options, root);
+  },
+
+  /* Construct a [i] index for a particular node */
+  _constructIndex: function(node) {
+    var index = '';
+    do {
+      if (node.id) index = '[' + node.position + ']' + index;
+    } while ((node = node.parent) != null);
+    return index;
+  },
 
   sequence: function(element) {
     element = $(element);
@@ -655,20 +853,63 @@ var Sortable = {
     });
    
     new_sequence.each(function(ident) {
-        var n = nodeMap[ident];
-        if (n) {
-            n[1].appendChild(n[0]);
-            delete nodeMap[ident];
-        }
+      var n = nodeMap[ident];
+      if (n) {
+        n[1].appendChild(n[0]);
+        delete nodeMap[ident];
+      }
     });
   },
-
+  
   serialize: function(element) {
     element = $(element);
+    var options = Object.extend(Sortable.options(element), arguments[1] || {});
     var name = encodeURIComponent(
       (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
-    return Sortable.sequence(element, arguments[1]).map( function(item) {
-      return name + "[]=" + encodeURIComponent(item);
-    }).join('&');
+    
+    if (options.tree) {
+      return Sortable.tree(element, arguments[1]).children.map( function (item) {
+        return [name + Sortable._constructIndex(item) + "=" + 
+                encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
+      }).flatten().join('&');
+    } else {
+      return Sortable.sequence(element, arguments[1]).map( function(item) {
+        return name + "[]=" + encodeURIComponent(item);
+      }).join('&');
+    }
   }
 }
+
+/* Returns true if child is contained within element */
+Element.isParent = function(child, element) {
+  if (!child.parentNode || child == element) return false;
+
+  if (child.parentNode == element) return true;
+
+  return Element.isParent(child.parentNode, element);
+}
+
+Element.findChildren = function(element, only, recursive, tagName) {    
+  if(!element.hasChildNodes()) return null;
+  tagName = tagName.toUpperCase();
+  if(only) only = [only].flatten();
+  var elements = [];
+  $A(element.childNodes).each( function(e) {
+    if(e.tagName && e.tagName.toUpperCase()==tagName &&
+      (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
+        elements.push(e);
+    if(recursive) {
+      var grandchildren = Element.findChildren(e, only, recursive, tagName);
+      if(grandchildren) elements.push(grandchildren);
+    }
+  });
+
+  return (elements.length>0 ? elements.flatten() : []);
+}
+
+Element.offsetSize = function (element, type) {
+  if (type == 'vertical' || type == 'height')
+    return element.offsetHeight;
+  else
+    return element.offsetWidth;
+}