nitro 0.25.0 → 0.26.0

data/lib/nitro/session.rb

@@ -6,6 +6,8 @@ require 'mega/time_in_english'
 
 require 'glue/attribute'
 require 'glue/configuration'
+require 'glue/logger'
+require 'glue/expirable'
 
 require 'nitro/cgi/cookie'
 
@@ -21,8 +23,11 @@ module Nitro
 # 
 # The session should be persistable to survive server 
 # shutdowns.
+#
+# TODO rehash of the session cookie
 
 class Session < Hash
+  is Expirable
 
   # Session id salt.
 
@@ -32,16 +37,19 @@ class Session < Hash
 
   setting :cookie_name, :default => 'nsid', :doc => 'The name of the cookie that stores the session id'
 
+  # useful with persistents sessions stores
+  
+  setting :cookie_expires, :default => false, :doc => 'Set expires parameter of session cookie equal to the keepalive setting?'
+
   # The session keepalive time. The session is eligable for
   # garbage collection after this time passes.
   
   setting :keepalive, :default => 30.minutes, :doc => 'The session keepalive time'
   
-  # The sessions store. By default sessions are 
-  # stored in memory.
-
-  cattr_accessor :store; @@store = SyncHash.new 
+  # The sessions store. 
 
+  cattr_accessor :store
+  
   class << self
   
     # Set the session store. The following options are
@@ -49,16 +57,19 @@ class Session < Hash
     #
     # * :memory [default]
     # * :drb
+    # * :og 
+    # * :file (not safe yet with multiple process as in fastcgi)
     # * :memcached (not available yet)
-    # * :og (not available yet)
-    # * :file (not available yet)
 
     def store_type=(store_type)
       # gmosx: RDoc complains about this, so lets use an
       # eval, AAAAAAAARGH!
       # require "nitro/session/#{store_type}"
+      Logger.debug "Using #{store_type} sessions."
+
       eval %{ require 'nitro/session/#{store_type}' }
     end
+    alias_method :set_store_type, :store_type=
 
     # Lookup the session in the store by using the session
     # cookie value as a key. If the session does not exist
@@ -74,6 +85,9 @@ class Session < Hash
         # Create new session.
         session = Session.new(context)
         cookie = Cookie.new(Session.cookie_name, session.session_id)
+        if Session.cookie_expires
+          cookie.expires = Time.now + Session.keepalive 
+        end
         context.add_cookie(cookie)
         Session.store[session.session_id] = session 
       else
@@ -84,54 +98,24 @@ class Session < Hash
       return session
     end
 
-    # Perform session garbage collection. Typically this method
-    # is called from a cron like mechanism (for example using
-    # script/runner).
-    
-    def garbage_collection!
-      Session.store.delete_if { |key, s| s.invalid? }
-    end
-    alias_method :gc!, :garbage_collection!
-    
-    # Helper method that returns all sessions.
-    
-    def all
-      Session.store.values
-    end
-    
   end
+
+  # By default sessions are stored in memory.
+  #--
+  # gmosx: should be placed here.
+  #++
   
+  set_store_type(:memory)  
+
   # The unique id of this session.
 
   attr_reader :session_id
 
-  # The time this session was created.
-
-  attr_reader :ctime
-  alias_method :create_time, :ctime
-
-  # The time this session was last modified.
-
-  attr_accessor :mtime
-  alias_method :modify_time, :mtime
-
-  # The time this session was last accessed.
-
-  attr_accessor :atime
-  alias_method :access_time, :mtime
-
   # Create the session for the given context.
 
   def initialize(context = nil)
     @session_id = create_id
-    @ctime = @mtime = @atime = Time.now
-  end
-
-  # Like the unix touch command, updates
-  # the atime to now.
-
-  def touch!
-    @atime = Time.now
+    expires_after(Session.keepalive)
   end
 
   # Synchronize the session store, by 
@@ -143,18 +127,9 @@ class Session < Hash
   end
   alias_method :restore, :sync
   
-  # Keep this session alive?
-  
-  def valid?
-    Time.now < @atime + Session.keepalive 
-  end
-  alias_method :alive?, :valid?
-  
-  # The reverse of keepalive?
-  
-  def invalid?
-    Time.now > @atime + Session.keepalive 
-  end
+  def touch!
+    expires_after(Session.keepalive)
+  end  
   
 protected
   
@@ -180,3 +155,4 @@ end
 end
 
 # * George Moschovitis <gm@navel.gr>
+# * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>

data/lib/nitro/session/drbserver.rb

@@ -53,7 +53,7 @@ rescue OptionParser::InvalidOption
   exit
 end
 
-sessions = SyncHash.new 
+sessions = Nitro::MemorySessionStore.new 
 
 if debug
 

data/lib/nitro/session/file.rb

@@ -1,40 +1,59 @@
 #!/usr/bin/env ruby
 
 require 'nitro/session'
+require 'fileutils'
+require 'tmpdir'
 
 module Nitro
-  class FileSessionStore
-    # The session keepalive time. The session is eligable for
-    # garbage collection after this time passes.
   
-    setting :path, :default => "/tmp/nitro_session", :doc => 'The directory to store file session'
+  # A Session manager that persists sessions on disk.
+  #
+  # TODO: safe locking of files, because Nitro can be multiprocess
+  
+  class FileSessionStore
+    setting :path, :default => "#{Dir.tmpdir}/nitro_session_#{Session.cookie_name}", :doc => 'The directory to store file session'
 
     def initialize
       @path = FileSessionStore.path
-      Dir.mkdir(@path) unless File.exists?(@path)
+      FileUtils.mkdir_p(@path)
     end
 
     def []=(k,v)
-      File.open(File.join(@path, k), "w") { |f| f.write(Marshal.dump(v)) }
+      fn = File.join(@path, k.to_s)
+      encode_file(fn, v)
     end
 
     def [](k)
-      fn = File.join(@path, k)
+      fn = File.join(@path, k.to_s)
       return nil unless File.exists?(fn)
+      decode_file(fn)
+    end
+
+    def gc!
+      now = Time.now
+      all.each do |fn|
+        expire_time = File.stat(fn).atime + Session.keepalive
+        File.delete(fn) if now > expire_time
+      end
+    end
+
+    def all
+      Dir.glob( File.join(@path, '*' ) )
+    end
+
+    private
+
+    def decode_file(fn)
       Marshal.load( File.read(fn) )
     end
 
-#    def values
-#      []
-#    end
-#
-#    def each
-#      #yield
-#    end
+    def encode_file(fn, value)
+      File.open(fn, "w") { |f| f.write(Marshal.dump(value)) }
+    end
 
   end
 
   Session.store = FileSessionStore.new
 end
 
-# * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>
+# * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>

data/lib/nitro/session/memory.rb

@@ -1,10 +1,19 @@
-require 'mega/synchash'
+module Nitro
 
-Logger.debug 'Using In-Memory sessions.'
+  class MemorySessionStore < SyncHash
 
-module Nitro
+    # Perform session garbage collection. Typically this method
+    # is called from a cron like mechanism (for example using
+    # script/runner).
+    
+    def gc!
+      delete_if { |key, s| s.expired? }
+    end
+
+    alias :all :values
+  end
 
-Session.store = SyncHash.new
+  Session.store = MemorySessionStore.new
 
 end
 

data/lib/nitro/session/og.rb

@@ -0,0 +1,56 @@
+require 'og'
+require 'nitro/session'
+require 'base64'
+
+module Nitro
+
+  class OgSession < Session
+    prop_accessor :sessionid, String
+    prop_accessor :expires, Time
+    prop_accessor :content
+  end
+
+  # A Session manager that persists sessions on an Og store.
+  
+  class OgSessionStore
+
+    def []=(k,v)
+      unless s = OgSession.find_by_sessionid(k.to_s)
+        s = OgSession.new
+        s.sessionid = k.to_s
+      end
+      #s.content = v.to_yaml
+      s.content = encode(v)
+      s.save
+    end
+
+    def [](k)
+      s = OgSession.find_by_sessionid(k.to_s) and decode(s.content)
+    end
+
+    def gc!
+      now = Og.manager.store.quote(Time.now)
+      OgSession.find(:condition => "expires < #{now}").each {|s| s.delete }
+    end
+
+    def all
+      OgSession.all
+    end
+
+    private
+
+    def encode(c)
+      Base64.encode64(Marshal.dump(c))
+    end
+
+    def decode(c)
+      Marshal::load(Base64.decode64(c)) 
+      #s.content = YAML::load(s.content)
+    end
+
+  end
+
+  Session.store = OgSessionStore.new
+end
+
+# * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>

data/proto/public/js/controls.js

@@ -80,7 +80,10 @@ Autocompleter.Base.prototype = {
 
   show: function() {
     if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
-    if(!this.iefix && (navigator.appVersion.indexOf('MSIE')>0) && (Element.getStyle(this.update, 'position')=='absolute')) {
+    if(!this.iefix && 
+      (navigator.appVersion.indexOf('MSIE')>0) &&
+      (navigator.userAgent.indexOf('Opera')<0) &&
+      (Element.getStyle(this.update, 'position')=='absolute')) {
       new Insertion.After(this.update, 
        '<iframe id="' + this.update.id + '_iefix" '+
        'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
@@ -718,4 +721,30 @@ Ajax.InPlaceEditor.prototype = {
       Event.stopObserving(this.options.externalControl, 'mouseout', this.mouseoutListener);
     }
   }
+};
+
+// Delayed observer, like Form.Element.Observer, 
+// but waits for delay after last key input
+// Ideal for live-search fields
+
+Form.Element.DelayedObserver = Class.create();
+Form.Element.DelayedObserver.prototype = {
+  initialize: function(element, delay, callback) {
+    this.delay     = delay || 0.5;
+    this.element   = $(element);
+    this.callback  = callback;
+    this.timer     = null;
+    this.lastValue = $F(this.element); 
+    Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
+  },
+  delayedListener: function(event) {
+    if(this.lastValue == $F(this.element)) return;
+    if(this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
+    this.lastValue = $F(this.element);
+  },
+  onTimerEvent: function() {
+    this.timer = null;
+    this.callback(this.element, $F(this.element));
+  }
 };

data/proto/public/js/dragdrop.js

@@ -1,7 +1,5 @@
 // Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
 // 
-// Element.Class part Copyright (c) 2005 by Rick Olson
-// 
 // See scriptaculous.js for full license.
 
 /*--------------------------------------------------------------------------*/
@@ -10,7 +8,7 @@ var Droppables = {
   drops: [],
 
   remove: function(element) {
-    this.drops = this.drops.reject(function(d) { return d.element==element });
+    this.drops = this.drops.reject(function(d) { return d.element==$(element) });
   },
 
   add: function(element) {
@@ -31,6 +29,8 @@ var Droppables = {
         options._containers.push($(containment));
       }
     }
+    
+    if(options.accept) options.accept = [options.accept].flatten();
 
     Element.makePositioned(element); // fix IE
     options.element = element;
@@ -43,55 +43,50 @@ var Droppables = {
     return drop._containers.detect(function(c) { return parentNode == c });
   },
 
-  isAffected: function(pX, pY, element, drop) {
+  isAffected: function(point, element, drop) {
     return (
       (drop.element!=element) &&
       ((!drop._containers) ||
         this.isContained(element, drop)) &&
       ((!drop.accept) ||
-        (Element.Class.has_any(element, drop.accept))) &&
-      Position.within(drop.element, pX, pY) );
+        (Element.classNames(element).detect( 
+          function(v) { return drop.accept.include(v) } ) )) &&
+      Position.within(drop.element, point[0], point[1]) );
   },
 
   deactivate: function(drop) {
     if(drop.hoverclass)
-      Element.Class.remove(drop.element, drop.hoverclass);
+      Element.removeClassName(drop.element, drop.hoverclass);
     this.last_active = null;
   },
 
   activate: function(drop) {
-    if(this.last_active) this.deactivate(this.last_active);
     if(drop.hoverclass)
-      Element.Class.add(drop.element, drop.hoverclass);
+      Element.addClassName(drop.element, drop.hoverclass);
     this.last_active = drop;
   },
 
-  show: function(event, element) {
+  show: function(point, element) {
     if(!this.drops.length) return;
-    var pX = Event.pointerX(event);
-    var pY = Event.pointerY(event);
-    Position.prepare();
-
-    var i = this.drops.length-1; do {
-      var drop = this.drops[i];
-      if(this.isAffected(pX, pY, element, drop)) {
+    
+    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) { 
-          this.activate(drop);
-          return;
+          Droppables.activate(drop);
+          throw $break;
         }
       }
-    } while (i--);
-    
-    if(this.last_active) this.deactivate(this.last_active);
+    });
   },
 
   fire: function(event, element) {
     if(!this.last_active) return;
     Position.prepare();
 
-    if (this.isAffected(Event.pointerX(event), Event.pointerY(event), element, this.last_active))
+    if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
       if (this.last_active.onDrop) 
         this.last_active.onDrop(element, this.last_active.element, event);
   },
@@ -103,15 +98,84 @@ var Droppables = {
 }
 
 var Draggables = {
+  drags: [],
   observers: [],
+  
+  register: function(draggable) {
+    if(this.drags.length == 0) {
+      this.eventMouseUp   = this.endDrag.bindAsEventListener(this);
+      this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
+      this.eventKeypress  = this.keyPress.bindAsEventListener(this);
+      
+      Event.observe(document, "mouseup", this.eventMouseUp);
+      Event.observe(document, "mousemove", this.eventMouseMove);
+      Event.observe(document, "keypress", this.eventKeypress);
+    }
+    this.drags.push(draggable);
+  },
+  
+  unregister: function(draggable) {
+    this.drags = this.drags.reject(function(d) { return d==draggable });
+    if(this.drags.length == 0) {
+      Event.stopObserving(document, "mouseup", this.eventMouseUp);
+      Event.stopObserving(document, "mousemove", this.eventMouseMove);
+      Event.stopObserving(document, "keypress", this.eventKeypress);
+    }
+  },
+  
+  activate: function(draggable) {
+    window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
+    this.activeDraggable = draggable;
+  },
+  
+  deactivate: function(draggbale) {
+    this.activeDraggable = null;
+  },
+  
+  updateDrag: function(event) {
+    if(!this.activeDraggable) return;
+    var pointer = [Event.pointerX(event), Event.pointerY(event)];
+    // Mozilla-based browsers fire successive mousemove events with
+    // the same coordinates, prevent needless redrawing (moz bug?)
+    if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
+    this._lastPointer = pointer;
+    this.activeDraggable.updateDrag(event, pointer);
+  },
+  
+  endDrag: function(event) {
+    if(!this.activeDraggable) return;
+    this._lastPointer = null;
+    this.activeDraggable.endDrag(event);
+  },
+  
+  keyPress: function(event) {
+    if(this.activeDraggable)
+      this.activeDraggable.keyPress(event);
+  },
+  
   addObserver: function(observer) {
-    this.observers.push(observer);    
+    this.observers.push(observer);
+    this._cacheObserverCallbacks();
   },
-  removeObserver: function(element) {  // element instead of obsever fixes mem leaks
+  
+  removeObserver: function(element) {  // element instead of observer fixes mem leaks
     this.observers = this.observers.reject( function(o) { return o.element==element });
+    this._cacheObserverCallbacks();
   },
-  notify: function(eventName, draggable) {  // 'onStart', 'onEnd'
-    this.observers.invoke(eventName, draggable);
+  
+  notify: function(eventName, draggable, event) {  // 'onStart', 'onEnd', 'onDrag'
+    if(this[eventName+'Count'] > 0)
+      this.observers.each( function(o) {
+        if(o[eventName]) o[eventName](eventName, draggable, event);
+      });
+  },
+  
+  _cacheObserverCallbacks: function() {
+    ['onStart','onEnd','onDrag'].each( function(eventName) {
+      Draggables[eventName+'Count'] = Draggables.observers.select(
+        function(o) { return o[eventName]; }
+      ).length;
+    });
   }
 }
 
@@ -127,68 +191,48 @@ Draggable.prototype = {
       },
       reverteffect: function(element, top_offset, left_offset) {
         var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
-        new Effect.MoveBy(element, -top_offset, -left_offset, {duration:dur});
+        element._revert = new Effect.MoveBy(element, -top_offset, -left_offset, {duration:dur});
       },
       endeffect: function(element) { 
-         new Effect.Opacity(element, {duration:0.2, from:0.7, to:1.0}); 
+        new Effect.Opacity(element, {duration:0.2, from:0.7, to:1.0}); 
       },
       zindex: 1000,
-      revert: false
+      revert: false,
+      snap: false   // false, or xy or [x,y] or function(x,y){ return [x,y] }
     }, arguments[1] || {});
 
-    this.element      = $(element);
+    this.element = $(element);
+    
     if(options.handle && (typeof options.handle == 'string'))
-      this.handle = Element.Class.childrenWith(this.element, options.handle)[0];
-      
+      this.handle = Element.childrenWithClassName(this.element, options.handle)[0];  
     if(!this.handle) this.handle = $(options.handle);
     if(!this.handle) this.handle = this.element;
 
     Element.makePositioned(this.element); // fix IE    
 
-    this.offsetX      = 0;
-    this.offsetY      = 0;
-    this.originalLeft = this.currentLeft();
-    this.originalTop  = this.currentTop();
-    this.originalX    = this.element.offsetLeft;
-    this.originalY    = this.element.offsetTop;
-
-    this.options      = options;
+    this.delta    = this.currentDelta();
+    this.options  = options;
+    this.dragging = false;   
 
-    this.active       = false;
-    this.dragging     = false;   
-
-    this.eventMouseDown = this.startDrag.bindAsEventListener(this);
-    this.eventMouseUp   = this.endDrag.bindAsEventListener(this);
-    this.eventMouseMove = this.update.bindAsEventListener(this);
-    this.eventKeypress  = this.keyPress.bindAsEventListener(this);
+    this.eventMouseDown = this.initDrag.bindAsEventListener(this);
+    Event.observe(this.handle, "mousedown", this.eventMouseDown);
     
-    this.registerEvents();
+    Draggables.register(this);
   },
+  
   destroy: function() {
     Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
-    this.unregisterEvents();
+    Draggables.unregister(this);
   },
-  registerEvents: function() {
-    Event.observe(document, "mouseup", this.eventMouseUp);
-    Event.observe(document, "mousemove", this.eventMouseMove);
-    Event.observe(document, "keypress", this.eventKeypress);
-    Event.observe(this.handle, "mousedown", this.eventMouseDown);
-  },
-  unregisterEvents: function() {
-    //if(!this.active) return;
-    //Event.stopObserving(document, "mouseup", this.eventMouseUp);
-    //Event.stopObserving(document, "mousemove", this.eventMouseMove);
-    //Event.stopObserving(document, "keypress", this.eventKeypress);
-  },
-  currentLeft: function() {
-    return parseInt(this.element.style.left || '0');
+  
+  currentDelta: function() {
+    return([
+      parseInt(this.element.style.left || '0'),
+      parseInt(this.element.style.top || '0')]);
   },
-  currentTop: function() {
-    return parseInt(this.element.style.top || '0')
-  },
-  startDrag: function(event) {
-    if(Event.isLeftClick(event)) {
-      
+  
+  initDrag: function(event) {
+    if(Event.isLeftClick(event)) {    
       // abort on form elements, fixes a Firefox issue
       var src = Event.element(event);
       if(src.tagName && (
@@ -196,20 +240,53 @@ Draggable.prototype = {
         src.tagName=='SELECT' ||
         src.tagName=='BUTTON' ||
         src.tagName=='TEXTAREA')) return;
+        
+      if(this.element._revert) {
+        this.element._revert.cancel();
+        this.element._revert = null;
+      }
       
-      // this.registerEvents();
-      this.active = true;
       var pointer = [Event.pointerX(event), Event.pointerY(event)];
-      var offsets = Position.cumulativeOffset(this.element);
-      this.offsetX =  (pointer[0] - offsets[0]);
-      this.offsetY =  (pointer[1] - offsets[1]);
+      var pos     = Position.cumulativeOffset(this.element);
+      this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
+      
+      Draggables.activate(this);
       Event.stop(event);
     }
   },
+  
+  startDrag: function(event) {
+    this.dragging = true;
+    
+    if(this.options.zindex) {
+      this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
+      this.element.style.zIndex = this.options.zindex;
+    }
+    
+    if(this.options.ghosting) {
+      this._clone = this.element.cloneNode(true);
+      Position.absolutize(this.element);
+      this.element.parentNode.insertBefore(this._clone, this.element);
+    }
+    
+    Draggables.notify('onStart', this, event);
+    if(this.options.starteffect) this.options.starteffect(this.element);
+  },
+  
+  updateDrag: function(event, pointer) {
+    if(!this.dragging) this.startDrag(event);
+    Position.prepare();
+    Droppables.show(pointer, this.element);
+    Draggables.notify('onDrag', this, event);
+    this.draw(pointer);
+    if(this.options.change) this.options.change(this);
+    
+    // fix AppleWebKit rendering
+    if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
+    Event.stop(event);
+  },
+  
   finishDrag: function(event, success) {
-    // this.unregisterEvents();
-
-    this.active = false;
     this.dragging = false;
 
     if(this.options.ghosting) {
@@ -219,18 +296,17 @@ Draggable.prototype = {
     }
 
     if(success) Droppables.fire(event, this.element);
-    Draggables.notify('onEnd', this);
+    Draggables.notify('onEnd', this, event);
 
     var revert = this.options.revert;
     if(revert && typeof revert == 'function') revert = revert(this.element);
-
+    
+    var d = this.currentDelta();
     if(revert && this.options.reverteffect) {
       this.options.reverteffect(this.element, 
-      this.currentTop()-this.originalTop,
-      this.currentLeft()-this.originalLeft);
+        d[1]-this.delta[1], d[0]-this.delta[0]);
     } else {
-      this.originalLeft = this.currentLeft();
-      this.originalTop  = this.currentTop();
+      this.delta = d;
     }
 
     if(this.options.zindex)
@@ -239,70 +315,48 @@ Draggable.prototype = {
     if(this.options.endeffect) 
       this.options.endeffect(this.element);
 
-
+    Draggables.deactivate(this);
     Droppables.reset();
   },
+  
   keyPress: function(event) {
-    if(this.active) {
-      if(event.keyCode==Event.KEY_ESC) {
-        this.finishDrag(event, false);
-        Event.stop(event);
-      }
-    }
+    if(!event.keyCode==Event.KEY_ESC) return;
+    this.finishDrag(event, false);
+    Event.stop(event);
   },
+  
   endDrag: function(event) {
-    if(this.active && this.dragging) {
-      this.finishDrag(event, true);
-      Event.stop(event);
-    }
-    this.active = false;
-    this.dragging = false;
+    if(!this.dragging) return;
+    this.finishDrag(event, true);
+    Event.stop(event);
   },
-  draw: function(event) {
-    var pointer = [Event.pointerX(event), Event.pointerY(event)];
-    var offsets = Position.cumulativeOffset(this.element);
-    offsets[0] -= this.currentLeft();
-    offsets[1] -= this.currentTop();
+  
+  draw: function(point) {
+    var pos = Position.cumulativeOffset(this.element);
+    var d = this.currentDelta();
+    pos[0] -= d[0]; pos[1] -= d[1];
+    
+    var p = [0,1].map(function(i){ return (point[i]-pos[i]-this.offset[i]) }.bind(this));
+    
+    if(this.options.snap) {
+      if(typeof this.options.snap == 'function') {
+        p = this.options.snap(p[0],p[1]);
+      } else {
+      if(this.options.snap instanceof Array) {
+        p = p.map( function(v, i) {
+          return Math.round(v/this.options.snap[i])*this.options.snap[i] }.bind(this))
+      } else {
+        p = p.map( function(v) {
+          return Math.round(v/this.options.snap)*this.options.snap }.bind(this))
+      }
+    }}
+    
     var style = this.element.style;
     if((!this.options.constraint) || (this.options.constraint=='horizontal'))
-      style.left = (pointer[0] - offsets[0] - this.offsetX) + "px";
+      style.left = p[0] + "px";
     if((!this.options.constraint) || (this.options.constraint=='vertical'))
-      style.top  = (pointer[1] - offsets[1] - this.offsetY) + "px";
+      style.top  = p[1] + "px";
     if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
-  },
-  update: function(event) {
-   if(this.active) {
-      if(!this.dragging) {
-        var style = this.element.style;
-        this.dragging = true;
-        
-        if(Element.getStyle(this.element,'position')=='') 
-          style.position = "relative";
-        
-        if(this.options.zindex) {
-          this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
-          style.zIndex = this.options.zindex;
-        }
-
-        if(this.options.ghosting) {
-          this._clone = this.element.cloneNode(true);
-          Position.absolutize(this.element);
-          this.element.parentNode.insertBefore(this._clone, this.element);
-        }
-
-        Draggables.notify('onStart', this);
-        if(this.options.starteffect) this.options.starteffect(this.element);
-      }
-
-      Droppables.show(event, this.element);
-      this.draw(event);
-      if(this.options.change) this.options.change(this);
-
-      // fix AppleWebKit rendering
-      if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0); 
-
-      Event.stop(event);
-   }
   }
 }
 
@@ -315,9 +369,11 @@ SortableObserver.prototype = {
     this.observer  = observer;
     this.lastValue = Sortable.serialize(this.element);
   },
+  
   onStart: function() {
     this.lastValue = Sortable.serialize(this.element);
   },
+  
   onEnd: function() {
     Sortable.unmark();
     if(this.lastValue != Sortable.serialize(this.element))
@@ -327,10 +383,12 @@ SortableObserver.prototype = {
 
 var Sortable = {
   sortables: new Array(),
+  
   options: function(element){
     element = $(element);
     return this.sortables.detect(function(s) { return s.element == element });
   },
+  
   destroy: function(element){
     element = $(element);
     this.sortables.findAll(function(s) { return s.element == element }).each(function(s){
@@ -340,6 +398,7 @@ var Sortable = {
     });
     this.sortables = this.sortables.reject(function(s) { return s.element == element });
   },
+  
   create: function(element) {
     element = $(element);
     var options = Object.extend({ 
@@ -413,7 +472,7 @@ var Sortable = {
     (this.findElements(element, options) || []).each( function(e) {
       // handles are per-draggable
       var handle = options.handle ? 
-        Element.Class.childrenWith(e, options.handle)[0] : e;    
+        Element.childrenWithClassName(e, options.handle)[0] : e;    
       options.draggables.push(
         new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
       Droppables.add(e, options_for_droppable);
@@ -433,8 +492,8 @@ var Sortable = {
     if(!element.hasChildNodes()) return null;
     var elements = [];
     $A(element.childNodes).each( function(e) {
-      if(e.tagName && e.tagName==options.tag.toUpperCase() &&
-        (!options.only || (Element.Class.has(e, options.only))))
+      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);
@@ -491,14 +550,20 @@ var Sortable = {
     if(!Sortable._marker) {
       Sortable._marker = $('dropmarker') || document.createElement('DIV');
       Element.hide(Sortable._marker);
-      Element.Class.add(Sortable._marker, 'dropmarker');
+      Element.addClassName(Sortable._marker, 'dropmarker');
       Sortable._marker.style.position = 'absolute';
       document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
     }    
     var offsets = Position.cumulativeOffset(dropon);
-    Sortable._marker.style.top  = offsets[1] + 'px';
-    if(position=='after') Sortable._marker.style.top = (offsets[1]+dropon.clientHeight) + 'px';
     Sortable._marker.style.left = offsets[0] + 'px';
+    Sortable._marker.style.top = offsets[1] + 'px';
+    
+    if(position=='after')
+      if(sortable.overlap == 'horizontal') 
+        Sortable._marker.style.left = (offsets[0]+dropon.clientWidth) + 'px';
+      else
+        Sortable._marker.style.top = (offsets[1]+dropon.clientHeight) + 'px';
+    
     Element.show(Sortable._marker);
   },
 
@@ -511,9 +576,9 @@ var Sortable = {
       name: element.id,
       format: sortableOptions.format || /^[^_]*_(.*)$/
     }, arguments[1] || {});
-    return $(this.findElements(element, options) || []).collect( function(item) {
+    return $(this.findElements(element, options) || []).map( function(item) {
       return (encodeURIComponent(options.name) + "[]=" + 
               encodeURIComponent(item.id.match(options.format) ? item.id.match(options.format)[1] : ''));
     }).join("&");
   }
-} 
+}