right-rails 1.2.1 → 1.2.2

data/CHANGELOG

@@ -1,3 +1,7 @@
+2011-06-12 Nikolay Nemshilov
+  o Version 1.2.2
+    * Rails 3.1 assets pipeline support
+
 2011-04-04 Nikolay Nemshilov
   o Version 1.2.0
     * RightJS 2.2.3 and plugins update

data/README.rdoc

@@ -23,33 +23,25 @@ helpers.
 
 == Installation
 
-RightRails is available as a normal ruby-gem
-
-    sudo gem install right-rails
-
-Or you can install it as a rails plugin
-
-    script/plugin install git://github.com/MadRabbit/right-rails.git
-
-In case of ruby-gem and Rails 3, add the following into your +Gemfile+
+Just add the following into your +Gemfile+
 
     gem 'right-rails'
 
-If you on Rails 2, add the following code into your +environment.rb+
+If you're on Rails < 3.1 then run the +right_rails+ generator
 
-    Rails::Initializer.run do |config|
-      config.gem 'right-rails'
-    end
+    script/generate right_rails
 
-Once you've done that, run the +right_rails+ generator
+If you're using Rails 3.1 with the pipeline assets handler, then you
+can require things in your +application.js+ file
 
-    script/generate right_rails
+    //= require right
+    //= require right/rails
 
-Or under Rails 3
+Or, you can use +right-rails+ automatic scripts handling by specifying
 
-    rails g right_rails
+    = javascript_include_tag :defaults
 
-Enjoy!
+In your layout file. It will hook all the scripts on its own.
 
 
 == Documentation

data/Rakefile

@@ -41,7 +41,7 @@ end
 namespace :rjs do
   CURRENT_DIR         = File.dirname(__FILE__)
 
-  OUTPUT_DIR          = CURRENT_DIR + '/public'
+  OUTPUT_DIR          = CURRENT_DIR + '/vendor'
   OUTPUT_JSS_DIR      = OUTPUT_DIR + "/javascripts"
   OUTPUT_IMG_DIR      = OUTPUT_DIR + "/images/rightjs-ui"
 
@@ -127,7 +127,7 @@ namespace :rjs do
 
     FileList["#{OUTPUT_JSS_DIR}/right/*.js"].each do |filename|
       old_content = File.read(filename)
-      new_content = old_content.gsub('url(../../img/', "url(/images/rightjs-ui/")
+      new_content = old_content.gsub('url(../../img/', "url(/assets/rightjs-ui/")
 
       if old_content != new_content
         puts "Patching: #{File.basename(filename)}"

data/init.rb

@@ -3,15 +3,22 @@
 require 'right_rails'
 
 if defined?(Rails)
+  unless ::Rails.version < "3.1"
+    module RightRails
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+
   if Rails::VERSION::MAJOR > 2
     # Rails 3 initializer
     require 'action_controller/railtie'
   end
-  
+
   if defined?(ActionController)
     class ActionController::Base
       include RightRails::ControllerExtensions
-  
+
       helper RightRails::Helpers::Basic,
              RightRails::Helpers::Rails,
              RightRails::Helpers::Forms,

data/lib/right_rails.rb

@@ -2,7 +2,7 @@
 # The RightRails module. Just a namespace
 #
 module RightRails
-  VERSION = '1.2.1'
+  VERSION = '1.2.2'
 
   autoload :Config,               'right_rails/config'
   autoload :JavaScriptGenerator,  'right_rails/java_script_generator'

data/vendor/assets/javascripts/right-olds-src.js

@@ -0,0 +1,652 @@
+/**
+ * The old browsers support module for RightJS
+ *
+ * Released under the terms of the MIT license
+ * Visit http://rightjs.org for more details
+ *
+ * Copyright (C) 2008-2011 Nikolay V. Nemshilov
+ */
+(function(RightJS) {
+/**
+ * Old IE browser hacks
+ *
+ *   Keep them in one place so they were more compact
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+if (RightJS.Browser.OLD && RightJS.Browser.IE) {
+  // loads DOM element extensions for selected elements
+  window.$ = RightJS.$ = (function(old_function) {
+    return function(id) {
+      var element = old_function(id);
+
+      // old IE browses match both, ID and NAME
+      if (element && element instanceof RightJS.Element &&
+        RightJS.isString(id) && element._.id !== id
+      ) {
+        element = RightJS.$(document).first('#'+ id);
+      }
+
+      return element;
+    };
+  })(RightJS.$);
+}
+
+
+/**
+ * Making the 'submit' and 'change' events bubble under IE browsers
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+
+/**
+ * Tests if there is the event support
+ *
+ * @param String event name
+ * @retrun Boolean check result
+ */
+function event_support_for(name, tag) {
+  var e = document.createElement(tag);
+  e.setAttribute(name, ';');
+  return isFunction(e[name]);
+}
+
+if (!event_support_for('onsubmit', 'form')) {
+  /**
+   * Emulates the 'submit' event bubbling for IE browsers
+   *
+   * @param raw dom-event
+   * @return void
+   */
+  var submit_boobler = function(raw_event) {
+    var event = $(raw_event), element = event.target._,
+        type = element.type, form = element.form, parent;
+
+    if (form && (parent = $(form).parent()) && (
+      (raw_event.keyCode === 13   && (type === 'text'   || type === 'password')) ||
+      (raw_event.type === 'click' && (type === 'submit' || type === 'image'))
+    )) {
+      event.type   = 'submit';
+      event.target = $(form);
+      parent.fire(event);
+    }
+  };
+
+  document.attachEvent('onclick',    submit_boobler);
+  document.attachEvent('onkeypress', submit_boobler);
+}
+
+if (!event_support_for('onchange', 'input')) {
+
+  var get_input_value = function(target) {
+    var element = target._,
+        type    = element.type;
+
+    return type === 'radio' || type === 'checkbox' ?
+      element.checked : target.getValue();
+  },
+
+  /**
+   * Emulates the 'change' event bubbling
+   *
+   * @param Event wrapped dom-event
+   * @param Input wrapped input element
+   * @return void
+   */
+  change_boobler = function(event, target) {
+    var parent  = target.parent(),
+        value   = get_input_value(target);
+
+    if (parent && ''+target._prev_value !== ''+value) {
+      target._prev_value = value; // saving the value so it didn't fire up again
+      event.type = 'change';
+      parent.fire(event);
+    }
+  },
+
+  /**
+   * Catches the input field changes
+   *
+   * @param raw dom-event
+   * @return void
+   */
+  catch_inputs_access = function(raw_event) {
+    var event  = $(raw_event),
+        target = event.target,
+        type   = target._.type,
+        tag    = target._.tagName,
+        input_is_radio = (type === 'radio' || type === 'checkbox');
+
+    if (
+      (event.type === 'click' && (input_is_radio || tag === 'SELECT')) ||
+      (event.type === 'keydown' && (
+        (event.keyCode == 13 && (tag !== 'TEXTAREA')) ||
+        type === 'select-multiple'
+      ))
+    ) {
+      change_boobler(event, target);
+    }
+  },
+
+  /**
+   * Catch inputs blur
+   *
+   * @param raw dom-event
+   * @return void
+   */
+  catch_input_left = function(raw_event) {
+    var event  = $(raw_event),
+        target = event.target;
+
+    if (target instanceof Input) {
+      change_boobler(event, target);
+    }
+  };
+
+  document.attachEvent('onclick',    catch_inputs_access);
+  document.attachEvent('onkeydown',  catch_inputs_access);
+  document.attachEvent('onfocusout', catch_input_left);
+
+  /**
+   * storing the input element previous value, so we could figure out
+   * if it was changed later on
+   */
+  document.attachEvent('onbeforeactivate', function(event) {
+    var element = $(event).target;
+
+    if (element instanceof Input) {
+      element._prev_value = get_input_value(element);
+    }
+  });
+}
+
+
+/**
+ * Konqueror browser fixes
+ *
+ * Copyright (C) 2009-2011 Nikolay V. Nemshilov
+ */
+
+/**
+ * manual position calculator, it works for Konqueror and also
+ * for old versions of Opera and FF
+ */
+if (!RightJS.$E('p')._.getBoundingClientRect) {
+  RightJS.Element.include({
+    position: function() {
+      var element  = this._,
+          top      = element.offsetTop,
+          left     = element.offsetLeft,
+          parent   = element.offsetParent;
+
+      while (parent) {
+        top  += parent.offsetTop;
+        left += parent.offsetLeft;
+
+        parent = parent.offsetParent;
+      }
+
+      return {x: left, y: top};
+    }
+  });
+}
+
+
+/**
+ * The manual css-selector feature implementation
+ *
+ * Credits:
+ *   - Sizzle    (http://sizzlejs.org)      Copyright (C) John Resig
+ *   - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2009-2011 Nikolay V. Nemshilov
+ */
+var has_native_css_selector = !!document.querySelector,
+    needs_css_engine_patch  = !has_native_css_selector;
+
+if (RightJS.Browser.IE8L) {
+  needs_css_engine_patch = true;
+}
+
+if (needs_css_engine_patch) {
+  /**
+   * The token searchers collection
+   */
+  var search = {
+    // search for any descendant nodes
+    ' ': function(element, tag) {
+      return RightJS.$A(element.getElementsByTagName(tag));
+    },
+
+    // search for immidate descendant nodes
+    '>': function(element, tag) {
+      var result = [], node = element.firstChild;
+      while (node) {
+        if (tag === '*' || node.tagName === tag) {
+          result.push(node);
+        }
+        node = node.nextSibling;
+      }
+      return result;
+    },
+
+    // search for immiate sibling nodes
+    '+': function(element, tag) {
+      while ((element = element.nextSibling)) {
+        if (element.tagName) {
+          return (tag === '*' || element.tagName === tag) ? [element] : [];
+        }
+      }
+      return [];
+    },
+
+    // search for late sibling nodes
+    '~': function(element, tag) {
+      var result = [];
+      while ((element = element.nextSibling)) {
+        if (tag === '*' || element.tagName === tag) {
+          result.push(element);
+        }
+      }
+      return result;
+    }
+  },
+
+
+  /**
+   * Collection of pseudo selector matchers
+   */
+  pseudos = {
+    not: function(node, css_rule) {
+      return node.nodeType === 1 && !RightJS.$(node).match(css_rule);
+    },
+
+    checked: function(node) {
+      return node.checked === true;
+    },
+
+    enabled: function(node) {
+      return node.disabled === false;
+    },
+
+    disabled: function(node) {
+      return node.disabled === true;
+    },
+
+    selected: function(node) {
+      return node.selected === true;
+    },
+
+    empty: function(node) {
+      return !node.firstChild;
+    },
+
+    'first-child': function(node, node_name) {
+      while ((node = node.previousSibling)) {
+        if (node.nodeType === 1 && (node_name === null || node.nodeName === node_name)) {
+          return false;
+        }
+      }
+      return true;
+    },
+
+    'first-of-type': function(node) {
+      return pseudos['first-child'](node, node.nodeName);
+    },
+
+    'last-child': function(node, node_name) {
+      while ((node = node.nextSibling)) {
+        if (node.nodeType === 1 && (node_name === null || node.nodeName === node_name)) {
+          return false;
+        }
+      }
+      return true;
+    },
+
+    'last-of-type': function(node) {
+      return pseudos['last-child'](node, node.nodeName);
+    },
+
+    'only-child': function(node, node_name) {
+      return pseudos['first-child'](node, node_name) &&
+        pseudos['last-child'](node, node_name);
+    },
+
+    'only-of-type': function(node) {
+      return pseudos['only-child'](node, node.nodeName);
+    },
+
+    'nth-child': function(node, number, node_name, reverse) {
+      var index = 1, a = number[0], b = number[1];
+
+      while ((node = (reverse === true) ? node.nextSibling : node.previousSibling)) {
+        if (node.nodeType === 1 && (node_name === undefined || node.nodeName === node_name)) {
+          index++;
+        }
+      }
+
+      return (b === undefined ? (index === a) : ((index - b) % a === 0 && (index - b) / a >= 0));
+    },
+
+    'nth-of-type': function(node, number) {
+      return pseudos['nth-child'](node, number, node.nodeName);
+    },
+
+    'nth-last-child': function(node, number) {
+      return pseudos['nth-child'](node, number, undefined, true);
+    },
+
+    'nth-last-of-type': function(node, number) {
+      return pseudos['nth-child'](node, number, node.nodeName, true);
+    }
+  },
+
+  // the regexps collection
+  chunker   = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,
+  id_re     = /#([\w\-_]+)/,
+  tag_re    = /^[\w\*]+/,
+  class_re  = /\.([\w\-\._]+)/,
+  pseudo_re = /:([\w\-]+)(\((.+?)\))*$/,
+  attrs_re  = /\[((?:[\w\-]*:)?[\w\-]+)\s*(?:([!\^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/,
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * Builds an atom matcher
+   *
+   * @param String atom definition
+   * @return Object atom matcher
+   */
+  atoms_cache = {},
+  build_atom = function(in_atom) {
+    if (!atoms_cache[in_atom]) {
+      var id, tag, classes, classes_length, attrs, pseudo,
+        values_of_pseudo, match, func, desc = {}, atom = in_atom;
+
+      // grabbing the attributes
+      while((match = atom.match(attrs_re))) {
+        attrs = attrs || {};
+        attrs[match[1]] = { o: match[2] || '', v: match[5] || match[6] || '' };
+        atom = atom.replace(match[0], '');
+      }
+
+      // extracting the pseudos
+      if ((match = atom.match(pseudo_re))) {
+        pseudo = match[1];
+        values_of_pseudo = match[3] === '' ? null : match[3];
+
+        if (pseudo.startsWith('nth')) {
+          // preparsing the nth-child pseoudo numbers
+          values_of_pseudo = values_of_pseudo.toLowerCase();
+
+          if (values_of_pseudo === 'n') {
+            // no need in the pseudo then
+            pseudo = null;
+            values_of_pseudo = null;
+          } else {
+            if (values_of_pseudo === 'odd')  { values_of_pseudo = '2n+1'; }
+            if (values_of_pseudo === 'even') { values_of_pseudo = '2n';   }
+
+            var m = /^([+\-]?\d*)?n([+\-]?\d*)?$/.exec(values_of_pseudo);
+            if (m) {
+              values_of_pseudo = [
+                m[1] === '-' ? -1 : parseInt(m[1], 10) || 1,
+                parseInt(m[2], 10) || 0
+              ];
+            } else {
+              values_of_pseudo = [parseInt(values_of_pseudo, 10), undefined];
+            }
+          }
+        }
+
+        atom = atom.replace(match[0], '');
+      }
+
+      // getting all the other options
+      id      = (atom.match(id_re)    || [1, null])[1];
+      tag     = (atom.match(tag_re)   || '*').toString().toUpperCase();
+      classes = (atom.match(class_re) || [1, ''])[1].split('.').without('');
+      classes_length = classes.length;
+
+      desc.tag = tag;
+
+      if (id || classes.length || attrs || pseudo) {
+        // optimizing a bit the values for quiker runtime checks
+        id      = id     || false;
+        attrs   = attrs  || false;
+        pseudo  = pseudo in pseudos ? pseudos[pseudo] : false;
+        classes = classes_length ? classes : false;
+
+        desc.filter = function(elements) {
+          var node, result = [], i=0, j=0, l = elements.length, failed;
+          for (; i < l; i++) {
+            node   = elements[i];
+
+            //////////////////////////////////////////////
+            // ID check
+            //
+            if (id !== false && node.id !== id) {
+              continue;
+            }
+
+            //////////////////////////////////////////////
+            // Class names check
+            if (classes !== false) {
+              var names = node.className.split(' '),
+                  names_length = names.length,
+                  x = 0; failed = false;
+
+              for (; x < classes_length; x++) {
+                for (var y=0, found = false; y < names_length; y++) {
+                  if (classes[x] === names[y]) {
+                    found = true;
+                    break;
+                  }
+                }
+
+                if (!found) {
+                  failed = true;
+                  break;
+                }
+              }
+
+              if (failed) { continue; }
+            }
+
+            ///////////////////////////////////////////////
+            // Attributes check
+            if (attrs !== false) {
+              var key, attr, operand, value; failed = false;
+              for (key in attrs) {
+                attr = key === 'class' ? node.className : (node.getAttribute(key) || '');
+                operand = attrs[key].o;
+                value   = attrs[key].v;
+
+                if (
+                  (operand === ''   && (key === 'class'|| key === 'lang' ?
+                    (attr === '') : (node.getAttributeNode(key) === null))) ||
+                  (operand === '='  && attr !== value) ||
+                  (operand === '*=' && attr.indexOf(value) === -1) ||
+                  (operand === '^=' && attr.indexOf(value) !== 0)  ||
+                  (operand === '$=' && attr.substring(attr.length - value.length) !== value) ||
+                  (operand === '~=' && attr.split(' ').indexOf(value) === -1) ||
+                  (operand === '|=' && attr.split('-').indexOf(value) === -1)
+                ) { failed = true; break; }
+              }
+
+              if (failed) { continue; }
+            }
+
+            ///////////////////////////////////////////////
+            // Pseudo selectors check
+            if (pseudo !== false) {
+              if (!pseudo(node, values_of_pseudo)) {
+                continue;
+              }
+            }
+
+            result[j++] = node;
+          }
+          return result;
+        };
+      }
+
+      atoms_cache[in_atom] = desc;
+    }
+
+    return atoms_cache[in_atom];
+  },
+
+  /**
+   * Builds a single selector out of a simple rule chunk
+   *
+   * @param Array of a single rule tokens
+   * @return Function selector
+   */
+  tokens_cache = {},
+  build_selector = function(rule) {
+    var rule_key = rule.join('');
+    if (!tokens_cache[rule_key]) {
+      for (var i=0; i < rule.length; i++) {
+        rule[i][1] = build_atom(rule[i][1]);
+      }
+
+      // creates a list of uniq nodes
+      var _uid = RightJS.$uid;
+      var uniq = function(elements) {
+        var uniq = [], uids = [], uid;
+        for (var i=0, length = elements.length; i < length; i++) {
+          uid = _uid(elements[i]);
+          if (!uids[uid]) {
+            uniq.push(elements[i]);
+            uids[uid] = true;
+          }
+        }
+
+        return uniq;
+      };
+
+      // performs the actual search of subnodes
+      var find_subnodes = function(element, atom) {
+        var result = search[atom[0]](element, atom[1].tag);
+        return atom[1].filter ? atom[1].filter(result) : result;
+      };
+
+      // building the actual selector function
+      tokens_cache[rule_key] = function(element) {
+        var founds, sub_founds;
+
+        for (var i=0, i_length = rule.length; i < i_length; i++) {
+          if (i === 0) {
+            founds = find_subnodes(element, rule[i]);
+
+          } else {
+            if (i > 1) { founds = uniq(founds); }
+
+            for (var j=0; j < founds.length; j++) {
+              sub_founds = find_subnodes(founds[j], rule[i]);
+
+              sub_founds.unshift(1); // <- nuke the parent node out of the list
+              sub_founds.unshift(j); // <- position to insert the subresult
+
+              founds.splice.apply(founds, sub_founds);
+
+              j += sub_founds.length - 3;
+            }
+          }
+        }
+
+        return rule.length > 1 ? uniq(founds) : founds;
+      };
+    }
+    return tokens_cache[rule_key];
+  },
+
+
+  /**
+   * Builds the list of selectors for the css_rule
+   *
+   * @param String raw css-rule
+   * @return Array of selectors
+   */
+  selectors_cache = {}, chunks_cache = {},
+  split_rule_to_selectors = function(css_rule) {
+    if (!selectors_cache[css_rule]) {
+      chunker.lastIndex = 0;
+
+      var rules = [], rule = [], rel = ' ', m, token;
+      while ((m = chunker.exec(css_rule))) {
+        token = m[1];
+
+        if (token === '+' || token === '>' || token === '~') {
+          rel = token;
+        } else {
+          rule.push([rel, token]);
+          rel = ' ';
+        }
+
+        if (m[2]) {
+          rules.push(build_selector(rule));
+          rule = [];
+        }
+      }
+      rules.push(build_selector(rule));
+
+      selectors_cache[css_rule] = rules;
+    }
+    return selectors_cache[css_rule];
+  },
+
+
+  /**
+   * The top level method, it just goes throught the css-rule chunks
+   * collect and merge the results that's it
+   *
+   * @param Element context
+   * @param String raw css-rule
+   * @return Array search result
+   */
+  select_all = function(element, css_rule) {
+    var selectors = split_rule_to_selectors(css_rule), result = [];
+    for (var i=0, length = selectors.length; i < length; i++) {
+      result = result.concat(selectors[i](element));
+    }
+
+    return result;
+  },
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+  // the previous dom-selection methods replacement
+  dom_extension = {
+    first: function(css_rule) {
+      return this.find(css_rule)[0];
+    },
+
+    find: function(css_rule, raw) {
+      var result, rule = css_rule || '*', element = this._, tag = element.tagName;
+
+      if (has_native_css_selector) {
+        try { // trying to reuse native css-engine under IE8
+          result = $A(element.querySelectorAll(rule));
+        } catch(e) { // if it fails use our own engine
+          result = select_all(element, rule);
+        }
+      } else {
+        result = select_all(element, rule);
+      }
+
+      return raw === true ? result : result.map(RightJS.$);
+    }
+  };
+
+  // hooking up the rightjs wrappers with the new methods
+  RightJS.$ext(RightJS.Element.prototype, dom_extension);
+  RightJS.$ext(RightJS.Document.prototype, dom_extension);
+}
+})(RightJS);