compages 0.4.0

data/vendor/plugins/unobtrusive_javascript/README

@@ -0,0 +1,73 @@
+= Unobtrusive Javascript for Rails Version 0.3.2
+
+Please see www.ujs4rails.com for full documentation, articles and updates.
+
+The Unobtrusive Javascript plugin for Rails allows you to attach Javascript behaviour and events to your page elements using pure Ruby, from within your controller or view, without clogging up your rendered HTML with Javascript - either inline or in the head of your document.
+
+== Installation
+
+The recommended way of installing the plugin is to take advantage of Subversion's svn:externals feature. From within your Rails app root, enter the following on the command line:
+
+  $ ./script/plugin install -x http://opensource.agileevolved.com/svn/root/rails_plugins/unobtrusive_javascript/tags/rel-0.2 unobtrusive_javascript
+
+If you are upgrading from a previous version remember to update your applications javascripts with:
+
+  rake unobtrusive_javascript:install
+
+Finally, add the necessary routes to config/routes.rb by adding:
+
+  UJS.routes
+
+To the Routes.draw block.
+
+== Including the necessary libraries and behaviours file
+
+The only modification you need to make to your app is to add the following line somewhere in the head of your app's layout:
+
+  <%= javascript_include_tag 'prototype', :unobtrusive %>
+
+You're now up and running with unobtrusive javascript functionality.
+
+== Registering javascript behaviours
+
+The plugin offers a simple, low-level function for attaching behaviours to elements of your page using the +register_js_behaviour+ function.
+
+  <%= apply_behaviour "#coolink:click", "alert('Hello world!')" %>
+
+You can also pass a block to the function that lets you write your javascript behaviours using ruby:
+
+  <%= apply_behaviour "#sayhellothenfade:click" do |page, element, event|
+	   page.alert "Hello, I'm gonna fade..."
+	   element.visual_effect :fade
+     end %>
+
+See the API documentation for more usage examples.
+
+=== Rendering behaviours inside script blocks instead of an external file
+
+By default, all unobtrusive behaviours will be rendered in an external javascript file, generated at runtime. Sometimes, you may want to embed the behaviours directly in a page, inside <tt>script</tt> tags. You can do this by passing the option <tt>:external => false</tt> to register_js_behaviour.
+
+  <%= apply_behaviour "#coolink:click", "alert('Hello world!')", :external => false %>
+
+One of the main reasons to render javascript inside javascript tags instead of the external file is when you are embedding behaviours inside partials that are loaded into your page using AJAX. Because the external javascript file will already have been generated, any subsequent behaviours inside your AJAX-loaded partials will not register. For this reason the behaviours need to be rendered inside normal script tags. The unobtrusive_javascript plugin takes care of this for you automatically - any behaviours registered inside an AJAX-loaded partial will be rendered inside a script element without having to specify <tt>:external => false</tt> manually.
+
+== Attaching behaviours directly to elements using Rails' tag generators
+
+Rails comes with two built-in tag generator helpers - tag and content_tag. You can use these helpers to generate HTML elements and attach behaviour to them by directly specifying the events as part of the helpers' html options hash. The behaviours will be extracted and moved into the external behaviours file instead of being rendered inline.
+
+  <%= content_tag "div", "Click Me", :onclick => "alert('You clicked me')" %>
+  
+The full range of javascript events are available through this method.
+
+The above functionality is achieved with a patch to Rails' tag_options function. Because of this patch, most of Rails' javascript/ajax helpers (or any helper that generates HTML using the tag_options function and that accepts an HTML options hash) will work in an unobtrusive fashion out of the box. The list of helpers that currently work unobtrusively include:
+
+* link_to_remote
+* link_to_function
+* button_to_function
+* form_remote_tag
+* submit_to_remote
+
+== Credits
+
+The unobtrusive_javascript plugin is by Luke Redpath (http://www.lukeredpath.co.uk) and Dan Webb (http://www.vivabit.com/bollocks).  The plugin also makes use of the Low Pro JavaScript library also by
+Dan Webb, parts of which were heavily inspired by Justin Palmer's excellent event:Selectors (http://encytemedia.com/eventselectors/).

data/vendor/plugins/unobtrusive_javascript/Rakefile

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'fileutils'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the unobtrusive_javascript plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the unobtrusive_javascript plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'UJS'
+  rdoc.options << '--line-numbers' << '--inline-source' << '--accessor=cattr_accessor'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Updates application with the necessary javascripts for unobtrusive_javascript.'
+task :update_scripts do
+  FileUtils.cp Dir['assets/javascripts/*.js'], '../../../public/javascripts'
+end
+
+desc 'Removes the javascripts for the plugin.'
+task :remove_scripts do
+  FileUtils.rm %{lowpro.js}.collect { |f| "../../../public/javascripts/" + f  }
+end

data/vendor/plugins/unobtrusive_javascript/about.yml

@@ -0,0 +1,6 @@
+author: Luke Redpath & Dan Webb
+summary: Makes adding javascript behaviour easy and enhances existing Rails javascript/ajax helpers.
+homepage: http://www.ujs4rails.com
+plugin: http://source.ujs4rails.com
+license: MIT
+version: 0.3

data/vendor/plugins/unobtrusive_javascript/assets/javascripts/lowpro.js

@@ -0,0 +1,307 @@
+LowPro = {};
+LowPro.Version = '0.1';
+
+// Adapted from DOM Ready extension by Dan Webb
+// http://www.vivabit.com/bollocks/2006/06/21/a-dom-ready-extension-for-prototype
+// which was based on work by Matthias Miller, Dean Edwards and John Resig
+//
+// Usage:
+//
+// Event.onReady(callbackFunction);
+Object.extend(Event, {
+  _domReady : function() {
+    if (arguments.callee.done) return;
+    arguments.callee.done = true;
+
+    if (Event._timer)  clearInterval(Event._timer);
+    
+    Event._readyCallbacks.each(function(f) { f() });
+    Event._readyCallbacks = null;
+    
+  },
+  onReady : function(f) {
+    if (!this._readyCallbacks) {
+      var domReady = this._domReady;
+      
+      if (domReady.done) return f();
+      
+      if (document.addEventListener)
+        document.addEventListener("DOMContentLoaded", domReady, false);
+        
+        /*@cc_on @*/
+        /*@if (@_win32)
+            document.write("<script id=__ie_onload defer src=javascript:void(0)><\/script>");
+            document.getElementById("__ie_onload").onreadystatechange = function() {
+                if (this.readyState == "complete") { domReady(); }
+            };
+        /*@end @*/
+        
+        if (/WebKit/i.test(navigator.userAgent)) { 
+          this._timer = setInterval(function() {
+            if (/loaded|complete/.test(document.readyState)) domReady(); 
+          }, 10);
+        }
+        
+        Event.observe(window, 'load', domReady);
+        Event._readyCallbacks =  [];
+    }
+    Event._readyCallbacks.push(f);
+  }
+});
+
+if (!Element.addMethods) 
+  Element.addMethods = function(o) { Object.extend(Element.Methods, o) };
+
+// Extend Element with observe and stopObserving.
+Element.addMethods({
+  observe : function(el, event, callback) {
+    Event.observe(el, event, callback);
+  },
+  stopObserving : function(el, event, callback) {
+    Event.stopObserving(el, event, callback);
+  }
+});
+
+// Replace out existing event observe code with Dean Edwards' addEvent
+// http://dean.edwards.name/weblog/2005/10/add-event/
+Object.extend(Event, {
+  observe : function(el, type, func) {
+    el = $(el);
+    if (!func.$$guid) func.$$guid = Event._guid++;
+  	if (!el.events) el.events = {};
+  	var handlers = el.events[type];
+  	if (!handlers) {
+  		handlers = el.events[type] = {};
+  		if (el["on" + type]) {
+  			handlers[0] = el["on" + type];
+  		}
+  	}
+  	handlers[func.$$guid] = func;
+  	el["on" + type] = Event._handleEvent;
+  	
+  	 if (!Event.observers) Event.observers = [];
+  	 Event.observers.push([el, name, func, false]);
+	},
+	stopObserving : function(el, type, func) {
+    if (el.events && el.events[type]) delete el.events[type][func.$$guid];
+  },
+  _handleEvent : function(e) {
+    var returnValue = true;
+    e = e || Event._fixEvent(window.event);
+    var handlers = this.events[e.type], el = $(this);
+    for (var i in handlers) {
+    	el.$$handleEvent = handlers[i];
+    	if (el.$$handleEvent(e) === false) returnValue = false;
+    }
+  	return returnValue;
+  },
+  _fixEvent : function(e) {
+    e.preventDefault = Event._preventDefault;
+    e.stopPropagation = Event._stopPropagation;
+    return e;
+  },
+  _preventDefault : function() { this.returnValue = false },
+  _stopPropagation : function() { this.cancelBubble = true },
+  _guid : 1
+});
+
+// Allows you to trigger an event element.  
+Object.extend(Event, {
+  trigger : function(element, event, fakeEvent) {
+    element = $(element);
+    fakeEvent = fakeEvent || { type :  event };
+    this.observers.each(function(cache) {
+      if (cache[0] == element && cache[1] == event)
+        cache[2].call(element, fakeEvent);
+    });
+  }
+});
+
+// Based on event:Selectors by Justin Palmer
+// http://encytemedia.com/event-selectors/
+//
+// Usage:
+//
+// Event.addBehavior({
+//      "selector:event" : function(event) { /* event handler.  this refers to the element. */ },
+//      "selector" : function() { /* runs function on dom ready.  this refers to the element. */ }
+//      ...
+// });
+//
+// Multiple calls will add to exisiting rules.  Event.addBehavior.reassignAfterAjax and
+// Event.addBehavior.autoTrigger can be adjusted to needs.
+Event.addBehavior = function(rules) {
+  var ab = this.addBehavior;
+  Object.extend(ab.rules, rules);
+  
+  if (ab.autoTrigger) {
+    this.onReady(ab.load.bind(ab));
+  }
+  
+  Ajax.Responders.register({
+    onComplete : function() { 
+      if (Event.addBehavior.reassignAfterAjax) 
+        setTimeout(function() { ab.load() }, 10);
+    }
+  });
+  
+};
+
+Object.extend(Event.addBehavior, {
+  rules : {}, cache : [],
+  reassignAfterAjax : true,
+  autoTrigger : true,
+  
+  load : function() {
+    this.unload();
+    for (var selector in this.rules) {
+      var observer = this.rules[selector];
+      var sels = selector.split(',');
+      sels.each(function(sel) {
+        var parts = sel.split(/:(?=[a-z]+$)/), css = parts[0], event = parts[1];
+        $$(css).each(function(element) {
+          if (event) {
+            $(element).observe(event, observer);
+            Event.addBehavior.cache.push([element, event, observer]);
+          } else {
+            if (!element.$$assigned || !element.$$assigned.include(observer)) {
+              if (observer.attach) observer.attach(element);
+              else observer.call($(element));
+              element.$$assigned = element.$$assigned || [];
+              element.$$assigned.push(observer);
+            }
+          }
+        });
+      });
+    }
+  },
+  
+  unload : function() {
+    this.cache.each(function(c) {
+      Event.stopObserving.apply(Event, c);
+    });
+  }
+  
+});
+
+Event.observe(window, 'unload', Event.addBehavior.unload.bind(Event.addBehavior));
+
+// Behaviors can be bound to elements to provide an object orientated way of controlling elements
+// and their behavior.  Use Behavior.create() to make a new behavior class then use attach() to
+// glue it to an element.  Each element then gets it's own instance of the behavior and any
+// methods called onxxx are bound to the relevent event.
+// 
+// Usage:
+// 
+// var MyBehavior = Behavior.create({
+//   onmouseover : function() { this.element.addClassName('bong') } 
+// });
+
+// Event.addBehavior({ 'a.rollover' : MyBehavior });
+Behavior = {
+  create : function(members) {
+    var behavior = Class.create();
+    behavior.prototype.initialize = Prototype.K;
+    Object.extend(behavior.prototype, members);
+    Object.extend(behavior, Behavior.ClassMethods);
+    return behavior;
+  },
+  ClassMethods : {
+    attach : function(element) {
+      var bound = new this;
+      bound.element = $(element);
+      this._bindEvents(bound);
+      return bound;
+    },
+    _bindEvents : function(bound) {
+      for (var member in bound)
+        if (member.match(/^on(.+)/) && typeof bound[member] == 'function')
+          bound.element.observe(RegExp.$1, bound[member].bindAsEventListener(bound));
+    }
+  }
+};
+
+
+// Original code by Sylvian Zimmer
+// http://www.sylvainzimmer.com/index.php/archives/2006/06/25/speeding-up-prototypes-selector/
+// Optimises execution speed of the $$ function.  Rewritten for readability by Justin Palmer.
+// 
+// Turn off optimisation with LowPro.optimize$$ = false;
+LowPro.SelectorLite = Class.create();
+LowPro.SelectorLite.prototype = {
+  initialize: function(selectors) {
+    this.results = []; 
+    this.selectors = []; 
+    this.index = 0;
+    
+    for(var i = selectors.length -1; i >= 0; i--) {
+      var params = { tag: '*', id: null, classes: [] };
+      var selector = selectors[i];
+      var needle = selector.length - 1;
+      
+      do {
+        var id = selector.lastIndexOf("#");
+        var klass = selector.lastIndexOf(".");
+        var cursor = Math.max(id, klass);
+        
+        if(cursor == -1) params.tag = selector.toUpperCase();
+        else if(id == -1 || klass == cursor) params.classes.push(selector.substring(klass + 1))
+        else if(!params.id) params.id = selector.substring(id + 1);
+        
+        selector = selector.substring(0, cursor);
+      } while(cursor > 0);
+      this.selectors[i] = params;
+    }
+    
+  },
+  
+  get: function(root) {
+    this.findElements(root || document, this.index == (this.selectors.length - 1));
+    return this.results;
+  },
+  
+  findElements: function(parent, descendant) {
+    var selector = this.selectors[this.index], results = [], element;
+    if(selector.id) {
+      element = $(selector.id);
+      if(element && (selector.tag == '*' || element.tagName == selector.tag) && 
+        (element.childOf(parent))) {
+        results = [element];
+      }
+    } else {
+      results = $A(parent.getElementsByTagName(selector.tag));
+    }
+    
+    if(selector.classes.length == 1) {
+      results = results.select(function(target) {
+       return $(target).hasClassName(selector.classes[0]);
+      });
+    } else if(selector.classes.length > 1) {
+      results = results.select(function(target) {
+        var klasses = $(target).classNames();
+        return selector.classes.all(function(klass) {
+          return klasses.include(klass);
+        });
+      });
+    }
+    
+    if(descendant) {
+      this.results = this.results.concat(results);
+    } else {
+      ++this.index;
+      results.each(function(target) {
+        this.findElements(target, this.index == (this.selectors.length - 1));
+      }.bind(this));
+    }
+  }
+}
+
+LowPro.$$old=$$;
+LowPro.optimize$$ = true;
+
+function $$(a,b) {
+  if (LowPro.optimize$$ == false || b || a.indexOf("[")>=0) 
+    return LowPro.$$old.apply(this, arguments);
+  return new LowPro.SelectorLite(a.split(/\s+/)).get();
+}
+

data/vendor/plugins/unobtrusive_javascript/init.rb

@@ -0,0 +1,21 @@
+require 'actionview_helpers_patches'
+require 'prototype_helper_patches'
+require 'scriptaculous_helper_patches'
+require 'asset_tag_helper_patches'
+require 'tag_helper_patches'
+require 'behaviour_caching'
+require 'ujs'
+
+# make plugin controllers and views available to app
+config.load_paths += %W(#{UJS::PLUGIN_CONTROLLER_PATH})
+Rails::Initializer.run(:set_load_path, config)
+
+# add methods to action controller base
+ActionController::Base.send(:include, UJS::ControllerMethods)
+
+# load in the helpers and caching code
+ActionController::Base.send(:helper, UJS::Helpers)
+ActionController::Base.send(:include, UJS::BehaviourCaching)
+
+# require the controller
+require 'unobtrusive_javascript_controller'

data/vendor/plugins/unobtrusive_javascript/install.rb

@@ -0,0 +1 @@
+`rake update_scripts`

data/vendor/plugins/unobtrusive_javascript/lib/actionview_helpers_patches.rb

@@ -0,0 +1,17 @@
+module ActionView::Helpers
+  def self.current_controller=(controller)
+    @@current_controller = controller
+  end
+  
+  def self.current_controller
+    @@current_controller
+  end
+end
+
+class ActionView::Helpers::InstanceTag
+  include UJS::Helpers
+  
+  def current_controller
+    ActionView::Helpers.current_controller
+  end
+end