edifice 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in edifice.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    edifice (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  edifice!

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 iCyte
+
+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,46 @@
+Edifice
+=======
+
+	Edifice is a Javascript framework released as a rails plugin.
+
+
+framework.js + associated helpers
+---------------------------------
+
+The idea here is to communicate which view is rendering to the javascript so that we can call the correct javascript files in an automagical way.
+
+All you need to do is add
+	<%= edifice_meta_tags %>
+to your layout, in the head.
+
+Then if you render an action, such as users/show, in the layout application, these functions[if they exist] will be fired on these js objects in the following order:
+
+document.ready:
+	- usersShow.onReady
+	- layoutsApplication.onReady
+	- [widgets are loaded]
+	- usersShow.onWidgetReady
+	- layoutsApplication.onWidgetReady
+	
+document.load:
+	- usersShow.onLoad
+	- layoutsApplication.onLoad
+
+suppose we then subsequently load users/edit via ajax, in the layout xhr. Then the following events will fire:
+	- usersEdit.onAjaxComplete
+	- layoutsXhr.onAjaxComplete
+	- usersShow.onAjaxComplete
+	- layoutsApplication.onAjaxComplete
+	- [widgets are loaded]
+	- usersEdit.onWidgetReady
+	- layoutsXhr.onWidgetReady
+	- usersShow.onWidgetReady
+	- layoutsApplication.onWidgetReady
+
+widgets
+-------
+
+forms
+-----
+
+Copyright (c) 2010 iCyte, released under the MIT license

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/edifice.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "edifice/version"
+
+Gem::Specification.new do |s|
+  s.name        = "edifice"
+  s.version     = Edifice::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Tom Coleman", "Zoltan Olah", "Joe Dollard"]
+  s.email       = ["tom@thesnail.org", "zol@me.com", "jdollard@gmail.com"]
+  s.homepage    = "http://github.com/tmeasday/edifice"
+  s.summary     = %q{Ediface is a Javascript framework released as a rails plugin.}
+  s.description = %q{The idea here is to communicate which view is rendering to the javascript so that we can call the correct javascript files in an automagical way.}
+
+  s.rubyforge_project = "edifice"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/init.rb

@@ -0,0 +1,9 @@
+require 'edifice'
+
+config.to_prepare do 
+  Edifice.install_js_files
+end
+
+ActionController::Base.send :include, Edifice::Controller
+# ActionMailer::Base.send :include, Edifice::Controller
+ActionView::Base.send :include, EdificeHelper

data/lib/edifice/version.rb

@@ -0,0 +1,3 @@
+module Edifice
+  VERSION = "0.0.1"
+end

data/lib/edifice.rb

@@ -0,0 +1,54 @@
+module Edifice
+  def self.install_js_files
+    install_dir = ::Rails.application.paths.public.javascripts.first
+    edifice_js_dir = File.join(File.dirname(__FILE__), 'public', 'javascripts', 'edifice')
+    
+    FileUtils.cp_r edifice_js_dir, install_dir
+  end
+  
+  module Controller
+    def self.included(controller)
+      controller.helper_method(:view_path, :view_path_normalized, 
+        :view_name, :view_name_normalized, :layout_name)
+      
+      unless (controller == ActionMailer::Base)
+        controller.after_filter(:write_edifice_headers)
+        controller.alias_method_chain(:_render_template, :edifice)
+      end
+    end
+    
+    def _render_template_with_edifice(options)
+      @view_path = options[:prefix]
+      @view_name = options[:template]
+      @layout = File.split(options[:layout]).last
+      
+      _render_template_without_edifice(options)
+    end
+    
+    def write_edifice_headers
+      response.headers['x-edifice-view_path'] = view_path_normalized
+      response.headers['x-edifice-view_name'] = view_name_normalized
+      response.headers['x-edifice-layout'] = layout_name
+    end
+    
+    def view_path
+      (@view_path || 'no_controller').gsub('/', '_')
+    end
+    
+    def view_path_normalized
+      view_path.camelcase(:lower)
+    end
+
+    def view_name
+      @view_name || 'no_view'
+    end
+    
+    def view_name_normalized
+      view_name.camelcase(:lower)
+    end
+    
+    def layout_name
+      @layout || 'no_layout'
+    end
+  end
+end

data/lib/edifice_helper.rb

@@ -0,0 +1,14 @@
+module EdificeHelper
+  # put this in your layout somewhere
+  def edifice_meta_tags
+    %(<meta name='edifice-view_path' content='#{view_path_normalized}'/>
+      <meta name='edifice-view_name' content='#{view_name_normalized}'/>
+      <meta name='edifice-layout' content='#{layout_name}'/>).html_safe
+  end
+  
+  # the default classes that get added to the body element when a view renders
+  # the c_ in front of view_path is for historical reasons
+  def edifice_body_classes
+    %(c_#{view_path} v_#{view_name} l_#{layout_name}").html_safe
+  end
+end

data/lib/public/javascripts/edifice/ajax_form.js

@@ -0,0 +1,187 @@
+/*
+  Turn a standard form into an 'ajax' form. 
+  
+    -- Relies on the action that the form points to to return a 422 with a new,
+    'errored' form if there is a (server-side) validation problem. 
+    Otherwise calls the various callbacks..
+    
+    Extra arguments:
+      - status_sel: the selector of an element to set the classes 'submitting/success/error'
+          on depending on the state of the form. Defaults to the form itself.
+      - validators: a hash of input selectors to validation functions (or names)
+          for client-side validation. 
+*/
+
+(function($){
+  $.edifice_widgets.ajax_form = function() {
+    return this.each(function(){
+      var settings = $(this).read_options({
+        status_sel: this, // element to set to .submitting/.success/.error as we submit
+        //default callbacks
+        error: function(x, t, e, form){
+          if (x.status >= 400 && x.status < 500) { // a CLIENT ERROR
+            //validation failed replace form with new one
+            var $new_form = $(x.responseText);
+            $(form).replaceWith($new_form);
+            // -- not sure this is the best way to pass extra settings through, but it seems to work.
+            $new_form.create_widget('ajax_form', settings);
+          } else if (x.status >= 500 && x.status < 600) { // a SERVER ERROR
+            // replace the body proxy with the result (i.e replace the entire page)
+            $('#body_proxy').before($(x.responseText)).remove();
+          } else {
+            alert('Form failed. Please try again.');
+          }
+        },
+        success: function(d, s, form){},
+        complete: function(x, t, form){},
+        submit: function(e){}, // return false to cancel submit
+        validators: {}
+      });
+      
+      // prepare the validators that are references
+      for (var selector in settings.validators) {
+        var validator = settings.validators[selector];
+        if (typeof(validator) === 'string') {
+          validator = settings.validators[selector] = $.edifice_widgets.ajax_form.validators[validator];
+        }
+        $(selector).bind('change.ajax_form', {validator: validator}, function(event) {
+          validate($(this), event.data.validator);
+        });
+      }
+      
+      
+      function set_status_class(name) {
+        $.each(['form_submitting', 'form_success', 'form_error'], function(i, old_name) {
+          $(settings.status_sel).removeClass(old_name);
+        });
+        $(settings.status_sel).addClass(name);
+      };
+      
+      $(this).bind("submit.ajax_form", function(ev){
+        var form = this;
+        
+        ev.preventDefault();
+        
+        // do client-side validations
+        var valid = true, $first_error;
+        for (var selector in settings.validators) {
+          if (!validate($(selector), settings.validators[selector])) {
+            if (valid) { valid = false; $first_error = $(selector); }
+          }
+        }
+        if (!valid) { $first_error.focus(); return false; }
+                
+        // fire a custom event allowing anyone to cancel the submission
+        var event = $.Event('submitting.ajax_form');
+        event.cancel = false;
+        event.submitEvent = ev;
+        $(form).trigger(event);
+        
+        if (event.cancel)
+          return false;
+          
+        // also run the user defined submit function
+        if (settings.submit(ev) === false) return false;
+        
+        // disable the first submit button on the form
+        $(form).find('input[type=submit]:first').attr('disabled', true);
+        
+        // set the status
+        set_status_class('form_submitting');
+        
+        // send up the form and process the results
+        $.ajax({
+          cache: false,
+          data: $.param($(form).serializeArray()),          
+          type: form.method,
+          url: form.action,
+          error: function (x, t, e) {
+            settings.error(x, t, e, form); 
+            set_status_class('form_error');
+          },
+          success: function (d, s) {
+            settings.success(d, s, form);
+            set_status_class('form_success');
+          },
+          complete: function (x, t) {
+            // enable the first submit button on the form
+            $(form).find('input[type=submit]:first').attr('disabled', false);
+            
+            settings.complete(x, t, form); 
+          }
+        });
+        
+        return false;
+      });
+    });    
+  };
+  
+  // call this on a div that represents a form element.
+  // sets the right classes and enables disables actual form elements
+  $.fn.form_element_state = function(command) {
+    switch (command) {
+      case 'disabled':
+        this.addClass('disabled')
+          .find('input, select').attr('disabled', true);
+        break;
+      case 'enabled':
+        this.removeClass('disabled')
+          .find('input, select').removeAttr('disabled');
+        break;
+    }
+    return this;
+  };
+  
+  function clearError(id) {
+    // run over the input and the label pointing to it
+    $('.fieldWithErrors').find('> #' + id + ', > label[for=' + id + ']').unwrap();
+    $('label[for=' + id  + ']').next('.formError').remove();
+  };
+  
+  function addError(id, error) {
+    // right now this is causing focus issues and we don't need it, so I won't waste time
+    // fixing it.... but it could be used for different form layouts...
+    // $('#' + id + ', label[for=' + id + ']').wrap('<div class="fieldWithErrors"></div>');
+    $('label[for=' + id  + ']').after('<div class="formError">' + error + '</div>');
+  };
+  
+  // calls a validator, and takes care of setting the errors string
+  function validate($input, validator) {
+    var id = $input.attr('id');
+    // clear existing validations
+    clearError(id);
+    
+    var error = validator($input);
+    if (error === true) {
+      return true;
+    } else {
+      addError(id, error);
+      return false;
+    }      
+  }
+  
+  // validators expect a form element and return true or an error message
+  $.edifice_widgets.ajax_form.validators = {
+    not_empty: function($input) {
+      return $input.val() ? true : 'must not be empty';
+    }
+  };
+
+  // standardize .focus() for input tags. IE doesn't place the focus at the 
+  // end of the input box, this fixes it
+  $.fn.inputFocus = function() {
+    return this.each(function(){
+      if ($.browser.msie) {
+        if (this.createTextRange) {
+          var FieldRange = this.createTextRange();
+          FieldRange.moveStart('character', this.value.length);
+          FieldRange.collapse();
+          FieldRange.select();
+        }
+      } else {
+        this.focus();
+      }
+    });
+  };
+}(jQuery));
+

data/lib/public/javascripts/edifice/framework.js

@@ -0,0 +1,205 @@
+/**
+  * @fileOverview a proto-framework for javascript-rails integration using jQuery
+  * @author Tom Coleman
+  * @author Zoltan Olah
+  * @author Joe Dollard
+  */
+
+jQuery.noConflict();
+
+/** 
+  @name $.fn 
+  @namespace
+  @description jQuery Plugins
+*/
+(function($){
+  /**
+   * Runs an 'event method' on a view object and a layout object defined by meta tags
+   * we specially set in every layout.
+   * 
+   * @param {String} methodName The method to call on the view object corresponding to event that's happening.
+   */
+  function page_level_hookup(methodName) {
+    var view_path = $('meta[name=edifice-view_path]').attr('content');
+    var view_name = $('meta[name=edifice-view_name]').attr('content');    
+    var layout    = $('meta[name=edifice-layout]').attr('content');
+    
+    hookup(methodName, view_path, view_name, layout);
+  };
+
+  /**
+   * Runs an 'event method' on a view object and a layout object defined by the headers
+   * we specially set on ajax requests.
+   * 
+   * @param {String} methodName The method to call on the view object corresponding to event that's happening.
+   * @param {XMLHttpRequest} request The returning ajax request.
+   */  
+  function ajax_hookup(methodName, request) {
+    var view_path = request.getResponseHeader('x-edifice-view_path');
+    var view_name = request.getResponseHeader('x-edifice-view_name');
+    var layout    = request.getResponseHeader('x-edifice-layout');
+    
+    hookup(methodName, view_path, view_name, layout);
+  }
+  
+  /**
+   * Runs an 'event method' on a view object and a layout object.
+   * @example hookup('onLoad', 'annos', 'list', 'application);
+   * Will call annosList.onLoad() and layoutsApplication.onLoad() if they exist.
+   * 
+   * @param {String} methodName The method to call on the view object corresponding to event that's happening.
+   * @param {String} view_path The camelcased path to the view, often the same as the controller name.
+   * @param {String} view_name The name of the view being rendered.
+   * @param {String} layout The layout being used. If there is no layout this is 'no_layout'
+   */
+  function hookup(methodName, view_path, view_name, layout) {
+    //capitalize the first character in a string
+    function capitalize_first_chr(str) {
+      if ((typeof(str) == 'undefined') || (str.length == 0)) {
+        return "";
+      }
+      
+      return str.charAt(0).toUpperCase().concat( str.substr(1) )
+    }
+    
+    hookup_once(view_path + capitalize_first_chr(view_name), methodName); // hookup the view    
+    hookup_once('layouts' + capitalize_first_chr(layout), methodName);
+  };
+
+  /**
+   * Runs an 'event method' on a view object if it exists.
+   * 
+   * @param {String} objectName The name of the view object, e.g annosList.
+   * @param {String} methodName The method to call on the view object corresponding to event that's happening.
+   */
+  function hookup_once(objectName, methodName) {
+    if (typeof window[objectName] != 'undefined') { // check for undefined in js
+      if (methodName in window[objectName]) {
+        eval("window['" + objectName + "']." + methodName + "();");
+      }
+    }
+  };
+
+  //when the dom is ready
+  $(document).ready(function() {
+    page_level_hookup('onReady');
+    $.attach_widgets();
+    page_level_hookup('onWidgetsReady');
+    $(document).trigger('widgetsReady');
+  });
+  
+  //when the page is fully loaded (all frames, images, etc)
+  $(window).load(function() {
+    page_level_hookup('onLoad');
+  });
+  
+  //after every ajax request
+  $(window).bind('ajaxComplete', function(event, request) {
+    ajax_hookup('onAjaxComplete', request);
+    page_level_hookup('onAjaxComplete');
+    $.attach_widgets();
+    ajax_hookup('onWidgetsReady', request);
+    page_level_hookup('onWidgetsReady');
+    $(document).trigger('widgetsReady');
+  });
+  
+  
+  // *********** EDIFACE WIDGET CODE *********** //
+    
+  /**
+    @name $.edifice_widgets 
+    @namespace 
+    @description Our widgets live here.
+   */
+  $.edifice_widgets = {};
+  
+  /**
+   * Runs attach_widget() on any widget found in the html which isn't already attached.
+   */  
+  $.attach_widgets = function() {
+   $('[data-widget]:not([data-widget-attached])').attach_widget();
+  };
+  
+  /**
+   * Call $.WIDGET_NAME on the matched elements where WIDGET_NAME is set in the
+   * data-widget attribute.
+   *
+   * @param {Object} extra_options Use these options in addition to those specified
+   * in the html as data-widget-OPTION_NAME=VALUE
+   *
+   * @throws {Exception} If a widget has already been attached.
+   * @throws {Exception} If the type of widget doesn't exist.
+   */
+  $.fn.attach_widget = function(extra_options) {
+    return this.each(function() {
+      var $e = $(this), fn_name = $e.attr('data-widget');
+
+      // error checking
+      if ($e.attr('data-widget-attached')) {
+        throw('attach_widget called on already attached widget.');
+      }
+      if (!(fn_name in $.edifice_widgets)) {
+        throw("edifice widget '" + fn_name + "'   is not defined.");
+      }
+
+      // attach extra options to the widget
+      if (typeof(extra_options) != 'undefined') {
+        $.each(extra_options, function(name, def) {
+          $e.data('widget-' + name, def);
+        });      
+      }
+
+      // load the widget up
+      $.edifice_widgets[fn_name].call($e);
+      $e.attr('data-widget-attached', true);
+    });
+  };
+  
+  /**
+   * Make a widget out of an element which doesn't already have data-widget set
+   * in the html.
+   *
+   * @param {String} Type Type of widget, e.g 'ajax_form'
+   * @param {Object} Options for widget.
+   */
+  $.fn.create_widget = function(type, options) {
+    return $(this).attr('data-widget', type).attach_widget(options);
+  };
+    
+  /**
+   * @constant
+   */
+  $.edifice_widgets.REQUIRED = '*** VALUE REQUIRED ***';
+  
+  /**
+   * Read the set of options attached to a widget via data-widget-OPTION_NAME
+   * in the html.
+   *
+   * @param {Object} defaults Specifies the names and default values of 
+   * applicable options. Set default value to $.edifice_widgets.REQUIRED to indicate
+   * a mandatory value.
+   *
+   * @returns {Object} The options calculated.
+   *
+   * @throws {Exception} If a required option is not found.
+   */  
+  $.fn.read_options = function(defaults) {
+    var that = this;
+    var options = {};
+    $.each(defaults, function(name, def) {
+      var val = that.data('widget-' + name) || that.attr('data-widget-' + name);
+      
+      if (val) {
+        options[name] = val;
+      } else {
+        if (def === $.edifice_widgets.REQUIRED) {
+          throw("Widget argument required: " + name);
+        }
+        
+        options[name] = def;
+      }
+    });
+    
+    return options;
+  }
+}(jQuery));

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: edifice
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tom Coleman
+- Zoltan Olah
+- Joe Dollard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-21 00:00:00 +11:00
+default_executable: 
+dependencies: []
+
+description: The idea here is to communicate which view is rendering to the javascript so that we can call the correct javascript files in an automagical way.
+email: 
+- tom@thesnail.org
+- zol@me.com
+- jdollard@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README
+- Rakefile
+- edifice.gemspec
+- init.rb
+- lib/edifice.rb
+- lib/edifice/version.rb
+- lib/edifice_helper.rb
+- lib/public/javascripts/edifice/ajax_form.js
+- lib/public/javascripts/edifice/framework.js
+has_rdoc: true
+homepage: http://github.com/tmeasday/edifice
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: edifice
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Ediface is a Javascript framework released as a rails plugin.
+test_files: []
+