rep.ajax.toolkit 0.3.0

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+*~
+pkg
+build

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 MIT Hyperstudio
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1 @@
+

data/Rakefile

@@ -0,0 +1,27 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "rep.ajax.toolkit"
+    s.summary = "Hyperstudio ajax tools"
+    s.description = "Hyperstudio ajax tools"
+    s.email = "yorkc@mit.edu"
+    s.homepage = "http://github.com/repertoire/rep.ajax.toolkit"
+    s.authors = ["Christopher York"]
+    s.add_dependency('repertoire-assets', '>=0.1.0')
+    s.add_dependency('rep.jquery', '>=1.3.2')
+  end
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "yardoc"
+  end
+ 
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+begin
+  require 'repertoire-assets'
+#  Repertoire::Assets::Tasks.new(:gem_excludes => ["jquery"])
+rescue LoadError
+  puts "Repertoire assets not available.  Install it with: sudo gem install repertoire-assets"
+end

data/TODO

@@ -0,0 +1 @@
+

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/public/javascripts/rep.ajax-validate.js

@@ -0,0 +1,192 @@
+//= require <jquery>
+//= require <jquery/form>
+
+//= require "../stylesheets/rep.ajax-validate.css"
+//= provide "../images/rep.ajax-validate/*"
+
+/*
+* Repertoire incremental form validation via ajax
+*
+* Requires the JQuery Form plugin (http://www.malsup.com/jquery/form/)
+* 
+* Copyright (c) 2009 MIT Hyperstudio
+* Christopher York, 03/2009
+* Revised 06/2009
+*/
+
+(function($) {
+  //
+  // Usage:
+  //
+  // Invoke ajaxValidate on the form to be incrementally validated.  On the server side,
+  //   your validation method should accept the same parameters as the form's actual submit method,
+  //   and return a JSON hash of errors in the form { field_name: [error1, error2, ...]}; or 'true' if the 
+  //   entire form validates.  By default, the plugin only enables the submit button when every
+  //   field is valid.
+  //
+  // Basic Example:
+  //
+  //   Only the url for the validation webservice is required.
+  //
+  //   $('#my form').ajaxValidate({ url: '/validate_user' })
+  //
+  // Example with options:
+  //
+  //   $('#my form').ajaxValidate({
+  //     url:      '/validate_user',                                         /* validation webservice url */
+  //     disable:  false,                                                    /* allow submit for invalid forms */
+  //     feedback: '#validation_feedback',                                   /* put feedback in a special div rather than per field */
+  //     delegate: { 'user[password_confirmation]': 'user[password]' }       /* validate password whenever confirmation changes */
+  //     initialize: true                                                    /* validate all fields on form load */
+  //   })
+  //
+  // Also, you can configure the format of the error html by redefining ajaxValidate.format.  To use the default styling,
+  //   link to the rep.ajax-validate.css file and associated assets.
+  //
+  // Note that input fields are identified by the 'name' attribute rather than id or class, for consistency
+  //   with form-processing code on the server side.  So if your form looks like:
+  //
+  // <form method="post" action="/users">
+  //   <div>Email:<input type="text" name="user[email]"/><div class='validate'/></div>
+  //   <div>Password:<input type="password" name="user[password]"/><div class='validate'/></div>
+  //   <div>Confirm:<input type="password" name="user[confirm_password]"/><div class='validate'/></div>
+  //   <div style="clear:both"><input type="submit"/></div>
+  // </form>
+  //
+  // Your validation web service should return JSON keyed to the text fields' name attributes:
+  //
+  // { 'user[email]': [ 'Email has already been taken by another user', 'Email must be in mit.edu domain' ], ... }
+  //
+  // One special case to ease usability: When the user hovers over the submit button in preparation to submit, the
+  //    validator runs if the input is disabled.  This handles a common case where the user has filled the final field
+  //    but not moved cursor focus.  Disabling is done via javascript rather than html, since some browsers swallow
+  //    all events for disabled inputs.
+  // 
+  $.fn.ajaxValidate = function($$options) {
+    // plugin defaults + options
+    var $settings = $.extend({}, $.fn.ajaxValidate.defaults, $$options);
+    return this.each(function() {
+      var $form = $(this);
+      // element specific options
+      var o = $.meta ? $.extend({}, $settings, $form.data()) : $settings;
+      // initialize and setup submit button
+      initialize($form, o, false);
+      // install event handlers to validate single fields when they lose focus
+      $form.find(':input').blur(function() {
+        // determine if field delegates to another and locate the feedback element
+        var field = canonical_field($form, $(this), o);
+        // remove existing feedback during server activity
+        field.$feedback.empty();
+        // core operation: submit form via ajax and update field feedback with formatted errors
+        validate_form($form, field.$feedback, o, function(data) {
+          disabled = data !== true
+    	    set_disabled($form, data !== true, o);
+      	  set_feedback(field.$feedback, data[field.name], o);
+        });
+      });
+      
+      // handle disabling form and submit button
+      if (o.disable) {
+        var $submit = $form.find(o.disable);
+        
+        // only allow submit if button not disabled
+        $form.submit(function() {
+          var disabled = $submit.hasClass('disabled');
+          var $validate = $form.find('.validate');
+          if (disabled) {
+            $validate.fadeOut(function() { $validate.fadeIn() });
+          }
+          return !disabled;
+        });
+        
+        // validate entire form when user hovers on disabled button
+        $submit.mouseover(function() {
+          initialize($form, o, true);
+        });
+      };      
+    });
+  };
+
+  //
+  // format errors.  pass in an array of strings, or true/undefined if there are no errors
+  //
+  $.fn.ajaxValidate.format = function(errors, opts) {
+    if (undefined != errors || true == errors) {
+      return '<ul class="error">' + $.map(errors, function(e) { return ('<li>' + e + '</li>'); }).join('') + '</ul>';
+    } else {
+      return '<ul class="pass"></ul>'
+    }
+  };
+
+  //
+  // option defaults
+  //
+  $.fn.ajaxValidate.defaults = {
+    initialize:    false,                    /* validate all fields' initial values when form loads */
+    feedback:      '~ .validate',            /* jquery selector for error feedback element, relative to the field it monitors */
+    disable:       ':input[type=submit]',     /* Disable submit button until form validates: supply selector or false */
+    type:          'POST',                   /* HTTP verb to use when calling web service */
+    delegate:      {},                       /* delegate validation of one field to another */
+    spinner:       'spinner',                /* css class to add to feedback during ajax processing */
+  };
+
+  // internal helper functions
+  
+  // pre-flight validation for all fields
+  function initialize($form, opts, force) {
+    validate_form($form, $form, opts, function(data) {
+      set_disabled($form, data != true, opts);
+      if (opts.initialize || force) {
+        $form.find(':input').each(function() {
+          var field = canonical_field($form, $(this), opts);
+          set_feedback(field.$feedback, data[field.name], opts);
+        });
+      }
+    });
+  }
+
+  // submit validation info to web service while displaying spinner
+  function validate_form($form, $feedback_elem, opts, callback) {
+    $feedback_elem.addClass(opts.spinner);
+    // submit the form contents to the validation web service
+    $form.ajaxSubmit({
+  	  url: opts.url,
+  	  type: opts.type,
+  	  dataType: 'json',
+    	beforeSend: function(xhr) { xhr.setRequestHeader("Accept", "application/json") }, /* JQuery uses wrong content type header */
+  	  success: function(data) {
+  	    // remove spinner and yield result to callback
+    	  $feedback_elem.removeClass(opts.spinner);
+    	  callback(data);
+  	  } 
+  	});    
+  }
+  
+  function canonical_field($form, $field, opts) {
+    // determine name of field to validate (this is the datamapper model attribute)
+    var field_name = $field.attr('name');
+    // handle fields whose validation delegates to another
+    if (opts.delegate[field_name] != undefined) {
+      field_name = opts.delegate[field_name];
+      $field     = $form.find(':input[name="' + field_name +'"]');
+    }
+    // determine element to display error feedback
+    var $feedback_elem = $field.find(opts.feedback);
+    // collect info on field that is being validated
+    return { name: field_name, $input: $field, $feedback: $feedback_elem }
+  }
+  
+  function set_disabled($form, status, opts) {
+    // enable/disable submit button, if option selected
+    if (opts.disable) {
+      if (status) $form.find(opts.disable).addClass('disabled');
+      else $form.find(opts.disable).removeClass('disabled');
+    }
+  }
+
+  function set_feedback($elem, errors, opts) {
+    // render error markup and update feedback element
+    markup = $.fn.ajaxValidate.format(errors, opts);
+    $elem.html(markup);
+  }
+})(jQuery);

data/public/javascripts/rep.hint.js

@@ -0,0 +1,37 @@
+//= require <jquery>
+
+jQuery.fn.hint = function (blurClass) {
+  if (!blurClass) { 
+    blurClass = 'blur';
+  }
+
+  return this.each(function () {
+    // get jQuery version of 'this'
+    var $input = jQuery(this),
+
+    // capture the rest of the variable to allow for reuse
+      title = $input.attr('title'),
+      $form = jQuery(this.form),
+      $win = jQuery(window);
+
+    function remove() {
+      if ($input.val() === title && $input.hasClass(blurClass)) {
+        $input.val('').removeClass(blurClass);
+      }
+    }
+
+    // only apply logic if the element has the attribute
+    if (title) { 
+      // on blur, set value to title attr if text is blank
+      $input.blur(function () {
+        if (this.value === '') {
+          $input.val(title).addClass(blurClass);
+        }
+      }).focus(remove).blur(); // now change all inputs to title
+
+      // clear the pre-defined text when form is submitted
+      $form.submit(remove);
+      $win.unload(remove); // handles Firefox's autocomplete
+    }
+  });
+};

data/public/javascripts/rep.widgets/events.js

@@ -0,0 +1,55 @@
+/*
+* Repertoire abstract event model, for use with widget model
+*
+* Copyright (c) 2009 MIT Hyperstudio
+* Christopher York, 11/2009
+*
+* Requires jquery 1.3.2+
+* Support: Firefox 3+ & Safari 4+.  IE emphatically not supported.
+*/
+
+//= require "global"
+
+//= require <jquery>
+
+//
+// Mixin that adds functionality for event listening to an arbitrary javascript object.
+//
+// API is the similar to jquery's bind, unbind, and trigger - except that events cannot be
+//     namespaced.
+//
+// N.B. This is not a true event dispatch system: there is no event object, just callbacks.
+//      Implementation may change.
+//
+repertoire.events = function(self, $proxy) {
+  
+  var handlers = {};
+
+  // mimic jquery's event bind
+  self.bind = function(type, fn) {
+    if (!handlers[type])
+      handlers[type] = [];
+      
+    handlers[type].push(fn);
+  };
+  
+  // mimic jquery's event unbind
+  self.unbind = function(type, fn) {
+    if (handlers[type]) {
+      handlers[type] = jQuery.grep(handlers[type], function(h) {
+        return h !== fn;
+      });
+    }
+  };
+
+  // wrap jquery's event trigger
+  self.trigger = function(type, data) {
+    if (handlers[type]) {
+      jQuery.each(handlers[type], function() {
+        this.call(self);
+      })
+    }
+  };
+  
+  return self;
+};

data/public/javascripts/rep.widgets/global.js

@@ -0,0 +1,52 @@
+/*
+* Repertoire abstract ajax widget
+*
+* Copyright (c) 2009 MIT Hyperstudio
+* Christopher York, 09/2009
+*
+* Requires jquery 1.3.2+
+* Support: Firefox 3+ & Safari 4+.  IE emphatically not supported.
+*/
+
+//= require <jquery>
+
+// claim a single global namespace, 'repertoire'
+repertoire = {};
+
+// Global defaults inherited by all widgets
+//
+// Options:
+//   path_prefix - prefix to add before all generated urls
+//
+repertoire.defaults = {
+  path_prefix: ''
+};
+
+//
+// Generates a jquery plugin that attaches a widget instance to each matched element
+// and exposes plugin defaults.
+//
+// N.B. This method is currently only in use in the faceting module, and may be deprecated.
+//
+// Usage:
+//    $.fn.my_widget = repertoire.plugin(my_widget);
+//    $.fn.my_widget.defaults = { /* widget option defaults */ };
+//
+repertoire.plugin = function(self) {
+  var fn = function(options) {
+    return this.each(function() {
+      var settings = $.extend({}, repertoire.defaults, fn.defaults, html_options($(this)), options);
+      self($(this), settings).initialize();
+    });
+  };
+  fn.defaults = { };
+  return fn;
+
+  // helper: default widget name and title options from dom
+  function html_options($elem) {
+    return {
+      name: $elem.attr('id'),
+      title: $elem.attr('title')
+    };
+  }
+};

data/public/javascripts/rep.widgets/model.js

@@ -0,0 +1,165 @@
+/*
+* Repertoire abstract ajax model, for use with widget framework
+*
+* Copyright (c) 2009 MIT Hyperstudio
+* Christopher York, 11/2009
+*
+* Requires jquery 1.3.2+
+* Support: Firefox 3+ & Safari 4+.  IE emphatically not supported.
+*/
+
+//= require "global"
+//= require "widget"
+//= require "events"
+
+//= require <jquery>
+
+//
+// Abstract model for ajax widgets.  This class includes convenience methods for listening to
+// events on models, for jquery ajax calls, and for param encoding in Merb's style.
+//
+// Handles:
+//       - change publication and observing
+//       - url/query-string construction
+//
+// Usage. The model provides a facade to your ajax webservice, and may hold state for a widget.
+//        In some cases (e.g. working with large server-side datasets), it may be appropriate to
+//        cache data in the model and fetch it as needed from the webservice.
+//
+// Using the ajax param encoders.  These convenience methods help you construct the url and
+//        assemble params for an ajax call.  It's not required to use them, although they make life
+//        easier.
+//
+// self.items = function(callback) {
+//   var url = self.default_url(['projects', 'results']);
+//   self.fetch(params, url, 'html', callback);
+// }
+//
+repertoire.model = function(options) {
+  // this object is an abstract class
+  var self = {};
+  
+  // default: no options specified
+  options = options || {};
+  
+  // mixin event handler functionality
+  repertoire.events(self);
+  
+  //
+  // Update the data model given the current state
+  //
+  // You may either pre-process the state and write your own webservice access methods
+  // or use self.fetch for a generic webservice, e.g.
+  //
+  // self.update = function(state, callback) {
+  //   var url = self.default_url(['projects', 'results']);
+  //   self.fetch(state, url, 'html', callback);
+  // }
+  //
+  self.update = function(state, callback) {
+    throw "Abstract function: redefine self.update() in your data model."
+  };
+  
+  //
+  // Utility method to issue an ajax HTTP GET to fetch data from a webservice
+  //
+  //   params:   params to send as http query line
+  //   url:      url of webservice to access
+  //   type:     type of data returned (e.g. 'json', 'html')
+  //   callback: function to call with returned data
+  //
+  self.fetch = function(params, url, type, callback, $elem, async) {
+    if (async == null)
+      async = true;
+
+    var spinnerClass = options.spinner || 'loading';
+    if ($elem)
+      $elem.addClass(spinnerClass);
+    $.ajax({
+      async:    async,
+      url:      url,
+      data:     self.to_query_string(params),
+      type:     'GET',
+      dataType: type,
+      // content negotiation problems may require:
+      /* beforeSend: function(xhr) { xhr.setRequestHeader("Accept", "application/json") } */
+      success:  callback,
+      error:    function(request, textStatus, errorThrown) {
+          if ($elem)
+            $elem.html(options.error || 'Could not load');
+      },
+      complete: function () {
+          if ($elem)
+            $elem.removeClass(spinnerClass);
+      }
+    });
+  };
+  
+  //
+  // Format a webservice url, preferring options.url if possible
+  //
+  self.default_url = function(default_parts, ext) {
+    var path_prefix = options.path_prefix || '';
+    var parts       = default_parts.slice();
+
+    parts.unshift(path_prefix);
+    url = options.url || parts.join('/')
+
+    if (ext)
+      url += '.' + ext;
+
+    return url;
+  }
+  
+  //
+  // Convert a structure of params to a URL query string suitable for use in an HTTP GET request, compliant with Merb's format.
+  //
+  //   An example:
+  //
+  //   Merb::Parse.params_to_query_string(:filter => {:year => [1593, 1597], :genre => ['Tragedy', 'Comedy'] }, :search => 'William')
+  //   ==> "filter[genre][]=Tragedy&filter[genre][]=Comedy&filter[year][]=1593&filter[year][]=1597&search=William"
+  //
+  self.to_query_string = function(value, prefix) {
+    var vs = [];
+    prefix = prefix || '';
+    if (value instanceof Array) {
+      jQuery.each(value, function(i, v) {
+        vs.push(self.to_query_string(v, prefix + '[]'));
+      });
+      return vs.join('&');
+    } else if (typeof(value) == "object") {
+      jQuery.each(value, function(k, v) {
+        vs.push(self.to_query_string(v, (prefix.length > 0) ? (prefix + '[' + escape(k) + ']') : escape(k)));
+      });
+      // minor addition to merb: discard empty value lists { e.g. discipline: [] }
+      vs = array_filter(vs, function(x) { return x !== ""; });
+      return vs.join('&');
+    } else {
+      return prefix + '=' + escape(value);
+    }
+  };
+
+  // Apparently IE doesn't support the filter function? -DD via Brett
+  var array_filter = function (thisArray, fun) {
+    var len = thisArray.length;
+      if (typeof fun != "function")
+        throw new TypeError();
+
+      var res = new Array();
+      var thisp = arguments[1];
+
+      for (var i = 0; i < len; i++) {
+        if (i in thisArray) {
+          var val = thisArray[i]; // in case fun mutates this
+          if (fun.call(thisp, val, i, thisArray)) 
+            res.push(val);
+	}
+      }
+
+      return res;
+  };
+
+    
+  // end of model factory function
+  return self;
+}

data/public/javascripts/rep.widgets/widget.js

@@ -0,0 +1,217 @@
+/*
+* Repertoire abstract ajax widget
+*
+* Copyright (c) 2009 MIT Hyperstudio
+* Christopher York, 09/2009
+*
+* Requires jquery 1.3.2+
+* Support: Firefox 3+ & Safari 4+.  IE emphatically not supported.
+*/
+
+//= require <jquery>
+
+//= require "global"
+
+//
+// Abstract class for ajax widgets
+//
+// Handles:
+//       - url/query-string construction
+//       - data assembly for sending to webservice
+//       - ui event delegation hooks
+//       - hooks for injecting custom behaviour
+//
+// Options on all subclassed widgets:
+//
+//   url         - provide a url to over-ride the widget's default
+//   spinner     - css class to add to widget during ajax loads
+//   error       - text to display if ajax load fails
+//   injectors   - additional jquery markup to inject into widget (see FAQ)
+//   handlers    - additional jquery event handlers to add to widget (see FAQ)
+//   state  - additional pre-processing for params sent to webservice (see FAQ)
+//
+// Sub-classes are required to over-ride one method: self.render().  If you wish to
+// use a data model, store a subclass of rep.wigets/model in your widget.
+//
+repertoire.widget = function(selector, options) {
+  // this object is an abstract class
+  var self    = {};
+  
+  // private variables
+  var $widget = $(selector);
+  options     = options || {};
+  
+  // mix in event handling functionality
+  repertoire.events(self, $widget);
+
+  // to run by hand after sub-classes have evaluated
+  self.initialize = function() {
+    // register any custom handlers
+    if (options.handlers !== undefined)
+      register_handlers(options.handlers);
+      
+    // load once at beginning
+    self.refresh();
+  }
+
+  //
+  // Refresh model and render into widget
+  //
+  // Integrates state and markup injectors
+  //
+  self.refresh = function() {
+    var callback;
+    
+    // pass to custom state processor
+    if (options.state !== undefined)
+      options.state(self);
+      
+    callback = function() {
+      // render the widget
+      var markup = self.render.apply(self, arguments);
+      
+      // inject any custom markup
+      if (options.injectors !== undefined)
+        // TODO.  figure out how to send all args to injectors
+        process_injectors(markup, options.injectors, arguments[0]);
+
+      // paint markup into the dom
+      if (markup)
+        $widget.html(markup);
+    };
+
+    // start rendering
+    self.reload(callback);
+  };
+
+  //
+  // Render and return markup for this widget.
+  //
+  // Three forms are possible:
+  //
+  // (1) Basic... just return a string or jquery object
+  //
+  //     self.render = function() {
+  //       return 'Hello world!';
+  //     };
+  //
+  // (2) If you just want to tweak the superclass' view:
+  // 
+  //     var template_fn = self.render;            // idiom to access super.render()
+  //     self.render = function() {
+  //       var markup = template_fn();
+  //       return $(markup).find('.title').html('New Title');
+  //     };
+  //
+  // (3) If you want to modify the DOM in place, do so
+  //     and return nothing.
+  //
+  self.render = function() {
+    return $('<div class="rep"/>');      // namespace for all other widget css is 'rep'
+  };
+  
+  
+  //
+  // A hook for use when your widget must render the results of an ajax callback.  Put
+  // the ajax call in self.reload().  Its results will be passed to self.render().
+  //
+  // self.reload = function(callback) {
+  //   $.get('http://www.nytimes.com', callback);
+  // };
+  //
+  // self.render = function(daily_news) {
+  //   $(daily_news).find('title').text();   // widget's view is the title of the new york times
+  // }
+  //
+  // N.B. In real-world cases, the call in self.reload should be to your
+  //      data model class, which serves as an ajax api facade.
+  //
+  self.reload = function(callback) {
+    callback();
+  }
+
+  //
+  // Register a handler for dom events on this widget.  Call with an event selector and a standard jquery event
+  // handler function, e.g.
+  //
+  //    self.handler('click.toggle_value!.rep .facet .value', function() { ... });
+  //
+  // Note the syntax used to identify a handler's event, namespace, and the jquery selector: '<event.namespace>!<target>'.
+  // Both event and namespace are optional - leave them out to register a click handler with a unique namespace.
+  //
+  // N.B. This method is intended only for protected use within a widget and its subclasses, since it depends
+  //      on the view implementation.
+  //
+  self.handler = function(event_selector, fn) {
+    event_selector = parse_event_selector(event_selector);
+    var event    = event_selector[0],
+        selector = event_selector[1];  // why doesn't JS support array decomposition?!?
+      
+    // bind new handler
+    $widget.bind(event, function (e) {
+      var $el = $(e.target);
+      var result = false;
+      // walk up dom tree for selector
+      while ($el.length > 0) {
+        if ($el.is(selector)) {
+          result = fn.apply($el[0], [e]);
+          if (result === false)
+            e.preventDefault();
+          return;
+        }
+        $el = $el.parent();
+      }
+    });
+  }
+  
+  // PRIVATE
+  
+  // register a collection of event handlers
+  function register_handlers(handlers) {
+    $.each(handlers, function(selector, handler) {
+      // register each handler
+      self.handler(selector, function() {
+        // bind self as an argument for the custom handler
+        return handler.apply(this, [self]);
+      });
+    });
+  }
+
+  // inject custom markup into widget
+  function process_injectors($markup, injectors, data) {
+    // workaround for jquery find not matching top element
+    $wrapped = $("<div/>").append($markup);
+
+    $.each(injectors, function(selector, injector) {
+      var $elems = $wrapped.find(selector);
+      if ($elems.length > 0) {
+        injector.apply($elems, [ self, data ]);
+      }
+    });
+  }
+  
+  // parse an event name and selector spec
+  function parse_event_selector(event_selector) {
+    var s = event_selector.split('!');
+    var event, selector;
+
+    if (s.length === 2) {
+      event = s[0], selector = s[1];
+    } else if (s.length === 1) {
+      event = 'click', selector = s[0];
+    } else {
+      throw "Could not parse event selector: " + event_selector;
+    }
+
+    if (event.indexOf('.')<0) {
+      // create a default namespace from selector or random number
+      namespace = selector.replace(/[^a-zA-z0-9]/g, '') || new Date().getTime();
+      event = event + '.' + namespace;
+    }
+
+    return [event, selector];
+  }
+
+  // end of widget factory function
+  return self;
+};

data/public/javascripts/rep.widgets.js

@@ -0,0 +1,13 @@
+/*
+* Repertoire abstract ajax widget
+*
+* Copyright (c) 2009 MIT Hyperstudio
+* Christopher York, 09/2009
+*
+* Requires jquery 1.3.2+
+* Support: Firefox 3+ & Safari 4+.  IE emphatically not supported.
+*/
+
+//= require "rep.widgets/global"
+//= require "rep.widgets/widget"
+//= require "rep.widgets/model"

data/public/stylesheets/rep.ajax-validate.css

@@ -0,0 +1,7 @@
+/* default css for the Repertoire ajax form validation widget */
+
+.validate           { float: left; padding-left: 5px; }
+.validate        ul { list-style-type: none; border: 0; margin: 0; padding: 0;}
+.validate .error li { background: url(../images/rep.ajax-validate/red_cross.png) no-repeat left center; color: red; padding-left:15px;}
+.validate .pass     { background: url(../images/rep.ajax-validate/green_check.png) no-repeat left center; color: green; min-height:15px; min-width:15px;}
+.validate.spinner   { background: url(../images/rep.ajax-validate/spinner_sm.gif) no-repeat left center; min-height:15px; min-width:15px;}

data/rep.ajax.toolkit.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rep.ajax.toolkit}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Christopher York"]
+  s.date = %q{2010-08-01}
+  s.description = %q{Hyperstudio ajax tools}
+  s.email = %q{yorkc@mit.edu}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README",
+     "TODO"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "lib/rep.ajax.toolkit.rb",
+     "public/images/rep.ajax-validate/green_check.png",
+     "public/images/rep.ajax-validate/red_cross.png",
+     "public/images/rep.ajax-validate/spinner_sm.gif",
+     "public/javascripts/rep.ajax-validate.js",
+     "public/javascripts/rep.hint.js",
+     "public/javascripts/rep.widgets.js",
+     "public/javascripts/rep.widgets/events.js",
+     "public/javascripts/rep.widgets/global.js",
+     "public/javascripts/rep.widgets/model.js",
+     "public/javascripts/rep.widgets/widget.js",
+     "public/stylesheets/rep.ajax-validate.css",
+     "rep.ajax.toolkit.gemspec"
+  ]
+  s.homepage = %q{http://github.com/repertoire/rep.ajax.toolkit}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Hyperstudio ajax tools}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<repertoire-assets>, [">= 0.1.0"])
+      s.add_runtime_dependency(%q<rep.jquery>, [">= 1.3.2"])
+    else
+      s.add_dependency(%q<repertoire-assets>, [">= 0.1.0"])
+      s.add_dependency(%q<rep.jquery>, [">= 1.3.2"])
+    end
+  else
+    s.add_dependency(%q<repertoire-assets>, [">= 0.1.0"])
+    s.add_dependency(%q<rep.jquery>, [">= 1.3.2"])
+  end
+end
+

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: rep.ajax.toolkit
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Christopher York
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-01 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: repertoire-assets
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rep.jquery
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 2
+        version: 1.3.2
+  type: :runtime
+  version_requirements: *id002
+description: Hyperstudio ajax tools
+email: yorkc@mit.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+- TODO
+files: 
+- .gitignore
+- LICENSE
+- README
+- Rakefile
+- TODO
+- VERSION
+- lib/rep.ajax.toolkit.rb
+- public/images/rep.ajax-validate/green_check.png
+- public/images/rep.ajax-validate/red_cross.png
+- public/images/rep.ajax-validate/spinner_sm.gif
+- public/javascripts/rep.ajax-validate.js
+- public/javascripts/rep.hint.js
+- public/javascripts/rep.widgets.js
+- public/javascripts/rep.widgets/events.js
+- public/javascripts/rep.widgets/global.js
+- public/javascripts/rep.widgets/model.js
+- public/javascripts/rep.widgets/widget.js
+- public/stylesheets/rep.ajax-validate.css
+- rep.ajax.toolkit.gemspec
+has_rdoc: true
+homepage: http://github.com/repertoire/rep.ajax.toolkit
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Hyperstudio ajax tools
+test_files: []
+