From 071e0ac1a01ef8d70334153f21d7228d79414454 Mon Sep 17 00:00:00 2001
From: Yomi Colledge <baphled@boodah.net>
Date: Mon, 21 Jun 2010 13:39:41 +0100
Subject: [PATCH] Added inflection and refactored the hover_dialog file to use
 inflection instead of our hack.

---
 app/views/layouts/no_sidebar.html.erb |   1 +
 public/javascripts/hover_dialog.js    |  13 +-
 public/javascripts/inflection.js      | 511 ++++++++++++++++++++++++++
 3 files changed, 515 insertions(+), 10 deletions(-)
 create mode 100644 public/javascripts/inflection.js

diff --git a/app/views/layouts/no_sidebar.html.erb b/app/views/layouts/no_sidebar.html.erb
index 5bd500ec..d1f9af92 100644
--- a/app/views/layouts/no_sidebar.html.erb
+++ b/app/views/layouts/no_sidebar.html.erb
@@ -20,6 +20,7 @@
   <%= javascript_include_tag "jquery.formtastic.tooltips" %>
   <%= javascript_include_tag "application" %>
   <%= javascript_include_tag "jquery-validate" %>
+  <%= javascript_include_tag "inflection" %>
   <%= javascript_include_tag "form" %>
   <%= yield :js_head %>
   <%= javascript_include_tag "http://cdn.jquerytools.org/1.2.0/all/jquery.tools.min.js" %>
diff --git a/public/javascripts/hover_dialog.js b/public/javascripts/hover_dialog.js
index 6f908c83..f47a964a 100644
--- a/public/javascripts/hover_dialog.js
+++ b/public/javascripts/hover_dialog.js
@@ -8,14 +8,8 @@ $(document).ready(function() {
   // We need singular & plural resource names to take advantage of hover dialog
   var formIdArray = $formID.split('_');
   var $resourceSingular = formIdArray[1];
-  var $resourcePlural = '';
+  var $resourcePlural = formIdArray[1].pluralize();
   
-  // Should really use some kind of pluralisation technique
-  if ($resourceSingular == 'story') {
-    $resourcePlural = 'stories'
-  } else {
-    $resourcePlural = $resourceSingular + 's';
-  };
   // Selector for our tag input
   var $tagInput = $('input#'+ $resourceSingular + '_tag_list');
   var $tagInputWrapper = $('li#'+ $resourceSingular + '_tag_list_input');
@@ -62,9 +56,8 @@ $(document).ready(function() {
 		      $tagInput.attr('value',$tagInput.attr('value') + $(this).html() + ', ');
 		      $(this).fadeOut();
           return false;
-        }))
-		    .append(' ')
-		    .fadeIn();
+        })
+      ).append(' ').fadeIn();
 	  };
 	};
 });
\ No newline at end of file
diff --git a/public/javascripts/inflection.js b/public/javascripts/inflection.js
new file mode 100644
index 00000000..8cd326bb
--- /dev/null
+++ b/public/javascripts/inflection.js
@@ -0,0 +1,511 @@
+/*
+Copyright (c) 2007 Ryan Schuft (ryan.schuft@gmail.com)
+
+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.
+*/
+
+/*
+  This code is based in part on the work done in Ruby to support
+  infection as part of Ruby on Rails in the ActiveSupport's Inflector
+  and Inflections classes.  It was initally ported to Javascript by
+  Ryan Schuft (ryan.schuft@gmail.com).
+
+  The code is available at http://code.google.com/p/inflection-js/
+
+  The basic usage is:
+    1. Include this script on your web page.
+    2. Call functions on any String object in Javascript
+
+  Currently implemented functions:
+
+    String.pluralize(plural) == String
+      renders a singular English language noun into its plural form
+      normal results can be overridden by passing in an alternative
+
+    String.singularize(singular) == String
+      renders a plural English language noun into its singular form
+      normal results can be overridden by passing in an alterative
+
+    String.camelize(lowFirstLetter) == String
+      renders a lower case underscored word into camel case
+      the first letter of the result will be upper case unless you pass true
+      also translates "/" into "::" (underscore does the opposite)
+
+    String.underscore() == String
+      renders a camel cased word into words seperated by underscores
+      also translates "::" back into "/" (camelize does the opposite)
+
+    String.humanize(lowFirstLetter) == String
+      renders a lower case and underscored word into human readable form
+      defaults to making the first letter capitalized unless you pass true
+
+    String.capitalize() == String
+      renders all characters to lower case and then makes the first upper
+
+    String.dasherize() == String
+      renders all underbars and spaces as dashes
+
+    String.titleize() == String
+      renders words into title casing (as for book titles)
+
+    String.demodulize() == String
+      renders class names that are prepended by modules into just the class
+
+    String.tableize() == String
+      renders camel cased singular words into their underscored plural form
+
+    String.classify() == String
+      renders an underscored plural word into its camel cased singular form
+
+    String.foreign_key(dropIdUbar) == String
+      renders a class name (camel cased singular noun) into a foreign key
+      defaults to seperating the class from the id with an underbar unless
+      you pass true
+      
+    String.ordinalize() == String
+      renders all numbers found in the string into their sequence like "22nd"
+*/
+
+/*
+  This function adds plurilization support to every String object
+    Signature:
+      String.pluralize(plural) == String
+    Arguments:
+      plural - String (optional) - overrides normal output with said String
+    Returns:
+      String - singular English language nouns are returned in plural form
+    Examples:
+      "person".pluralize() == "people"
+      "octopus".pluralize() == "octopi"
+      "Hat".pluralize() == "Hats"
+      "person".pluralize("guys") == "guys"
+*/
+if(!String.prototype.pluralize)String.prototype.pluralize=function(plural)
+{
+  var str=this;
+  if(plural)str=plural;
+  else
+  {
+    var uncountable=false;
+    for(var x=0;!uncountable&&x<this._uncountable_words.length;x++)
+      uncountable=(this._uncountable_words[x]==str.toLowerCase());
+    if(!uncountable) 
+    {
+      var matched=false;
+      for(var x=0;!matched&&x<this._plural_rules.length;x++)
+      {
+        matched=str.match(this._plural_rules[x][0]);
+        if(matched)
+          str=str.replace(this._plural_rules[x][0],this._plural_rules[x][1]);
+      }
+    }
+  }
+  return str;
+};
+
+/*
+  This function adds singularization support to every String object
+    Signature:
+      String.singularize(singular) == String
+    Arguments:
+      singular - String (optional) - overrides normal output with said String
+    Returns:
+      String - plural English language nouns are returned in singular form
+    Examples:
+      "people".singularize() == "person"
+      "octopi".singularize() == "octopus"
+      "Hats".singularize() == "Hat"
+      "guys".singularize("person") == "person"
+*/
+if(!String.prototype.singularize)
+  String.prototype.singularize=function(singular)
+  {
+    var str=this;
+    if(singular)str=singular;
+    else
+    {
+      var uncountable=false;
+      for(var x=0;!uncountable&&x<this._uncountable_words.length;x++)
+        uncountable=(this._uncountable_words[x]==str.toLowerCase());
+      if(!uncountable)
+      {
+        var matched=false;
+        for(var x=0;!matched&&x<this._singular_rules.length;x++)
+        {
+          matched=str.match(this._singular_rules[x][0]);
+          if(matched)
+            str=str.replace(this._singular_rules[x][0],
+              this._singular_rules[x][1]);
+        }
+      }
+    }
+    return str;
+  };
+
+/*
+  This is a list of nouns that use the same form for both singular and plural.
+  This list should remain entirely in lower case to correctly match Strings.
+  You can override this list for all Strings or just one depending on if you
+  set the new values on prototype or on a given String instance.
+*/
+if(!String.prototype._uncountable_words)String.prototype._uncountable_words=[
+  'equipment','information','rice','money','species','series','fish','sheep',
+  'moose','deer','news'
+];
+
+/*
+  These rules translate from the singular form of a noun to its plural form.
+  You can override this list for all Strings or just one depending on if you
+  set the new values on prototype or on a given String instance.
+*/
+if(!String.prototype._plural_rules)String.prototype._plural_rules=[
+  [new RegExp('(m)an$','gi'),'$1en'],
+  [new RegExp('(pe)rson$','gi'),'$1ople'],
+  [new RegExp('(child)$','gi'),'$1ren'],
+  [new RegExp('^(ox)$','gi'),'$1en'],
+  [new RegExp('(ax|test)is$','gi'),'$1es'],
+  [new RegExp('(octop|vir)us$','gi'),'$1i'],
+  [new RegExp('(alias|status)$','gi'),'$1es'],
+  [new RegExp('(bu)s$','gi'),'$1ses'],
+  [new RegExp('(buffal|tomat|potat)o$','gi'),'$1oes'],
+  [new RegExp('([ti])um$','gi'),'$1a'],
+  [new RegExp('sis$','gi'),'ses'],
+  [new RegExp('(?:([^f])fe|([lr])f)$','gi'),'$1$2ves'],
+  [new RegExp('(hive)$','gi'),'$1s'],
+  [new RegExp('([^aeiouy]|qu)y$','gi'),'$1ies'],
+  [new RegExp('(x|ch|ss|sh)$','gi'),'$1es'],
+  [new RegExp('(matr|vert|ind)ix|ex$','gi'),'$1ices'],
+  [new RegExp('([m|l])ouse$','gi'),'$1ice'],
+  [new RegExp('(quiz)$','gi'),'$1zes'],
+  [new RegExp('s$','gi'),'s'],
+  [new RegExp('$','gi'),'s']
+];
+
+/*
+  These rules translate from the plural form of a noun to its singular form.
+  You can override this list for all Strings or just one depending on if you
+  set the new values on prototype or on a given String instance.
+*/
+if(!String.prototype._singular_rules)String.prototype._singular_rules=[
+  [new RegExp('(m)en$','gi'),'$1an'],
+  [new RegExp('(pe)ople$','gi'),'$1rson'],
+  [new RegExp('(child)ren$','gi'),'$1'],
+  [new RegExp('([ti])a$','gi'), '$1um'],
+  [new RegExp('((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$',
+    'gi'),'$1$2sis'],
+  [new RegExp('(hive)s$','gi'), '$1'],
+  [new RegExp('(tive)s$','gi'), '$1'],
+  [new RegExp('(curve)s$','gi'), '$1'],
+  [new RegExp('([lr])ves$','gi'), '$1f'],
+  [new RegExp('([^fo])ves$','gi'), '$1fe'],
+  [new RegExp('([^aeiouy]|qu)ies$','gi'), '$1y'],
+  [new RegExp('(s)eries$','gi'), '$1eries'],
+  [new RegExp('(m)ovies$','gi'), '$1ovie'],
+  [new RegExp('(x|ch|ss|sh)es$','gi'), '$1'],
+  [new RegExp('([m|l])ice$','gi'), '$1ouse'],
+  [new RegExp('(bus)es$','gi'), '$1'],
+  [new RegExp('(o)es$','gi'), '$1'],
+  [new RegExp('(shoe)s$','gi'), '$1'],
+  [new RegExp('(cris|ax|test)es$','gi'), '$1is'],
+  [new RegExp('(octop|vir)i$','gi'), '$1us'],
+  [new RegExp('(alias|status)es$','gi'), '$1'],
+  [new RegExp('^(ox)en','gi'), '$1'],
+  [new RegExp('(vert|ind)ices$','gi'), '$1ex'],
+  [new RegExp('(matr)ices$','gi'), '$1ix'],
+  [new RegExp('(quiz)zes$','gi'), '$1'],
+  [new RegExp('s$','gi'), '']
+];
+
+/*
+  This function adds camelization support to every String object
+    Signature:
+      String.camelize(lowFirstLetter) == String
+    Arguments:
+      lowFirstLetter - boolean (optional) - default is to capitalize the first
+        letter of the results... passing true will lowercase it
+    Returns:
+      String - lower case underscored words will be returned in camel case
+        additionally '/' is translated to '::'
+    Examples:
+      "message_properties".camelize() == "MessageProperties"
+      "message_properties".camelize(true) == "messageProperties"
+*/
+if(!String.prototype.camelize)
+  String.prototype.camelize=function(lowFirstLetter)
+  {
+    var str=this.toLowerCase();
+    var str_path=str.split('/');
+    for(var i=0;i<str_path.length;i++)
+    {
+      var str_arr=str_path[i].split('_');
+      var initX=((lowFirstLetter&&i+1==str_path.length)?(1):(0));
+      for(var x=initX;x<str_arr.length;x++)
+        str_arr[x]=str_arr[x].charAt(0).toUpperCase()+str_arr[x].substring(1);
+      str_path[i]=str_arr.join('');
+    }
+    str=str_path.join('::');
+    return str;
+  };
+
+/*
+  This function adds underscore support to every String object
+    Signature:
+      String.underscore() == String
+    Arguments:
+      N/A
+    Returns:
+      String - camel cased words are returned as lower cased and underscored
+        additionally '::' is translated to '/'
+    Examples:
+      "MessageProperties".camelize() == "message_properties"
+      "messageProperties".underscore() == "message_properties"
+*/
+if(!String.prototype.underscore)
+  String.prototype.underscore=function()
+  {
+    var str=this;
+    var str_path=str.split('::');
+    var upCase=new RegExp('([ABCDEFGHIJKLMNOPQRSTUVWXYZ])','g');
+    var fb=new RegExp('^_');
+    for(var i=0;i<str_path.length;i++)
+      str_path[i]=str_path[i].replace(upCase,'_$1').replace(fb,'');
+    str=str_path.join('/').toLowerCase();
+    return str;
+  };
+
+/*
+  This function adds humanize support to every String object
+    Signature:
+      String.humanize(lowFirstLetter) == String
+    Arguments:
+      lowFirstLetter - boolean (optional) - default is to capitalize the first
+        letter of the results... passing true will lowercase it
+    Returns:
+      String - lower case underscored words will be returned in humanized form
+    Examples:
+      "message_properties".humanize() == "Message properties"
+      "message_properties".humanize(true) == "message properties"
+*/
+if(!String.prototype.humanize)
+  String.prototype.humanize=function(lowFirstLetter)
+  {
+    var str=this.toLowerCase();
+    str=str.replace(new RegExp('_id','g'),'');
+    str=str.replace(new RegExp('_','g'),' ');
+    if(!lowFirstLetter)str=str.capitalize();
+    return str;
+  };
+
+/*
+  This function adds capitalization support to every String object
+    Signature:
+      String.capitalize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - all characters will be lower case and the first will be upper
+    Examples:
+      "message_properties".capitalize() == "Message_properties"
+      "message properties".capitalize() == "Message properties"
+*/
+if(!String.prototype.capitalize)
+  String.prototype.capitalize=function()
+  {
+    var str=this.toLowerCase();
+    str=str.substring(0,1).toUpperCase()+str.substring(1);
+    return str;
+  };
+
+/*
+  This function adds dasherization support to every String object
+    Signature:
+      String.dasherize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - replaces all spaces or underbars with dashes
+    Examples:
+      "message_properties".capitalize() == "message-properties"
+      "Message Properties".capitalize() == "Message-Properties"
+*/
+if(!String.prototype.dasherize)
+  String.prototype.dasherize=function()
+  {
+    var str=this;
+    str=str.replace(new RegExp('[\ _]','g'),'-');
+    return str;
+  };
+
+/*
+  This function adds titleize support to every String object
+    Signature:
+      String.titleize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - capitalizes words as you would for a book title
+    Examples:
+      "message_properties".titleize() == "Message Properties"
+      "message properties to keep".titleize() == "Message Properties to Keep"
+*/
+if(!String.prototype.titleize)
+  String.prototype.titleize=function()
+  {
+    var str=this.toLowerCase();
+    var t=new RegExp('^'+this._non_titlecased_words.join('$|^')+'$','i');
+    str=str.replace(new RegExp('_','g'),' ');
+    var str_arr=str.split(' ');
+    for(var x=0;x<str_arr.length;x++)
+    {
+      var d=str_arr[x].split('-');
+      for(var i=0;i<d.length;i++)if(!d[i].match(t))d[i]=d[i].capitalize();
+      str_arr[x]=d.join('-');
+    }
+    str=str_arr.join(' ');
+    str=str.substring(0,1).toUpperCase()+str.substring(1);
+    return str;
+  };
+
+/*
+  This is a list of words that should not be capitalized for title case.
+  You can override this list for all Strings or just one depending on if you
+  set the new values on prototype or on a given String instance.
+*/
+if(!String.prototype._non_titlecased_words)
+  String.prototype._non_titlecased_words=[
+    'and','or','nor','a','an','the','so','but','to','of','at','by','from',
+    'into','on','onto','off','out','in','over','with','for'
+  ];
+
+/*
+  This function adds demodulize support to every String object
+    Signature:
+      String.demodulize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - removes module names leaving only class names (Ruby style)
+    Examples:
+      "Message::Bus::Properties".demodulize() == "Properties"
+*/
+if(!String.prototype.demodulize)
+  String.prototype.demodulize=function()
+  {
+    var str=this;
+    var str_arr=str.split('::');
+    str=str_arr[str_arr.length-1];
+    return str;
+  };
+
+/*
+  This function adds tableize support to every String object
+    Signature:
+      String.tableize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - renders camel cased words into their underscored plural form
+    Examples:
+      "MessageBusProperty".tableize() == "message_bus_properties"
+*/
+if(!String.prototype.tableize)
+  String.prototype.tableize=function()
+  {
+    var str=this;
+    str=str.underscore().pluralize();
+    return str;
+  };
+
+/*
+  This function adds classification support to every String object
+    Signature:
+      String.classify() == String
+    Arguments:
+      N/A
+    Returns:
+      String - underscored plural nouns become the camel cased singular form
+    Examples:
+      "message_bus_properties".classify() == "MessageBusProperty"
+*/
+if(!String.prototype.classify)
+  String.prototype.classify=function()
+  {
+    var str=this;
+    str=str.camelize().singularize();
+    return str;
+  };
+
+/*
+  This function adds foreign key support to every String object
+    Signature:
+      String.foreign_key(dropIdUbar) == String
+    Arguments:
+      dropIdUbar - boolean (optional) - default is to seperate id with an
+        underbar at the end of the class name, you can pass true to skip it
+    Returns:
+      String - camel cased singular class names become underscored with id
+    Examples:
+      "MessageBusProperty".foreign_key() == "message_bus_property_id"
+      "MessageBusProperty".foreign_key(true) == "message_bus_propertyid"
+*/
+if(!String.prototype.foreign_key)
+  String.prototype.foreign_key=function(dropIdUbar)
+  {
+    var str=this;
+    str=str.demodulize().underscore()+((dropIdUbar)?(''):('_'))+'id';
+    return str;
+  };
+
+/*
+  This function adds ordinalize support to every String object
+    Signature:
+      String.ordinalize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - renders all found numbers their sequence like "22nd"
+    Examples:
+      "the 1 pitch".ordinalize() == "the 1st pitch"
+*/
+if(!String.prototype.ordinalize)
+  String.prototype.ordinalize=function()
+  {
+    var str=this;
+    var str_arr=str.split(' ');
+    for(var x=0;x<str_arr.length;x++)
+    {
+	var i=parseInt(str_arr[x]);
+        if(""+i!="NaN")
+        {
+          var ltd=str_arr[x].substring(str_arr[x].length-2);
+          var ld=str_arr[x].substring(str_arr[x].length-1);
+          var suf="th";
+          if(ltd!="11"&&ltd!="12"&&ltd!="13")
+          {
+            if(ld=="1")suf="st";
+            else if(ld=="2")suf="nd";
+            else if(ld=="3")suf="rd";
+          }
+          str_arr[x]+=suf;
+        }
+    }
+    str=str_arr.join(' ');
+    return str;
+  };
+