best_in_place_mongoid 1.0.2

data/.gitignore

@@ -0,0 +1,11 @@
+.DS_Store
+.bundle
+pkg/*
+
+Gemfile.lock
+test_app/.bundle
+test_app/db/*.sqlite3
+test_app/log/*.log
+test_app/tmp/**/*
+
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in best_in_place.gemspec
+gemspec
+
+gem 'sqlite3-ruby', :require => 'sqlite3'
+gem 'jquery-rails'

data/README.md

@@ -0,0 +1,163 @@
+# Best In Place Mongoid
+
+##Description
+
+**Best in Place Mongoid** is a fork of **Best in Place** prepared for Mongoid documents.
+**Best in place** jQuery based AJAX Inplace-Editor that takes profit of RESTful server-side controllers to allow users to edit stuff with
+no need of forms. If the server have standard defined REST methods, particularly those to UPDATE your objects (HTTP PUT), then by adding the
+Javascript file to the application it is making all the fields with the proper defined classes to become user in-place editable.
+
+The editor works by PUTting the updated value to the server and GETting the updated record afterwards to display the updated value.
+
+[**SEE DEMO**](http://bipapp.heroku.com/)
+
+---
+
+##Features
+
+- Compatible with text **inputs**
+- Compatible with **textarea**
+- Compatible with **select** dropdown with custom collections
+- Compatible with custom boolean values (same usage of **checkboxes**)
+- Sanitize HTML and trim spaces of user's input on user's choice
+- Displays server-side **validation** errors
+- Allows external activator
+- ESC key destroys changes (requires user confirmation)
+- Autogrowing textarea
+
+---
+
+##Usage of Rails 3 Gem
+
+**best_in_place object, field, OPTIONS**
+
+Params:
+
+- **object** (Mandatory): The Object parameter represents the object itself you are about to modify
+- **field** (Mandatory): The field (passed as symbol) is the attribute of the Object you are going to display/edit.
+
+Options:
+
+- **:type** It can be only [:input, :textarea, :select, :checkbox] or if undefined it defaults to :input.
+- **:collection**: In case you are using the :select type then you must specify the collection of values it takes. In case you are
+  using the :checkbox type you can specify the two values it can take, or otherwise they will default to Yes and No.
+- **:path**: URL to which the updating action will be sent. If not defined it defaults to the :object path.
+- **:nil**: The nil param defines the content displayed in case no value is defined for that field. It can be something like "click me to edit".
+  If not defined it will show *"-"*.
+- **:activator**: Is the DOM object that can activate the field. If not defined the user will making editable by clicking on it.
+- **:sanitize**: True by default. If set to false the input/textarea will accept html tags.
+- **:html_args**: Hash of html arguments, such as maxlength, default-value etc.
+
+
+Examples (code in the views):
+
+### Input
+
+    <%= best_in_place @user, :name, :type => :input %>
+
+    <%= best_in_place @user, :name, :type => :input, :nil => "Click me to add content!" %>
+
+### Textarea
+
+    <%= best_in_place @user, :description, :type => :textarea %>
+
+### Select
+
+    <%= best_in_place @user, :country, :type => :select, :collection => [[1, "Spain"], [2, "Italy"], [3, "Germany"], [4, "France"]] %>
+
+Of course it can take an instance or global variable for the collection, just remember the structure [[key, value], [key, value],...].
+The key can be a string or an integer.
+
+### Checkbox
+
+    <%= best_in_place @user, :receive_emails, :type => :checkbox, :collection => ["No, thanks", "Yes, of course!"] %>
+
+The first value is always the negative boolean value and the second the positive. Structure: ["false value", "true value"].
+If not defined, it will default to *Yes* and *No* options.
+
+### Display server validation errors
+
+If you are using a Rails application, your controller's should respond to json in case of error.
+Example:
+
+    def update
+      @user = User.find(params[:id])
+
+      respond_to do |format|
+        if @user.update_attributes(params[:user])
+          format.html { redirect_to(@user, :notice => 'User was successfully updated.') }
+          format.json { head :ok }
+        else
+          format.html { render :action => "edit" }
+          format.json { render :json => @user.errors.full_messages, :status => :unprocessable_entity }
+        end
+      end
+    end
+
+At the same time, you must define the restrictions, validations and error messages in the model, as the example below:
+
+  # TODO - example
+
+When the user tries to introduce invalid data, the error messages defined in the model will be displayed in pop-up windows using the jQuery.purr plugin.
+
+---
+
+##Installation
+
+It works by simply copying and loading the files from the folder **/public/javascripts** to your application and loading them in your layouts
+in the following order:
+
+- jquery-1.4.4.js
+- jquery.purr.js
+- **best_in_place.js**
+
+The last one you can copy it (and keeping up to date to the last version) by running the following generator in your application's root.
+Remember to do it every time you update the gem (or you will see no change).
+
+    rails g best_in_place:setup
+
+To be able to use the script the following block must be added as well:
+
+    $(document).ready(function() {
+      /* Activating Best In Place */
+      jQuery(".best_in_place").best_in_place()
+    });
+
+In order to use the Rails 3 gem, just add the following line to the gemfile:
+
+    gem "best_in_place"
+
+----
+
+## Security
+
+If the script is used with the Rails Gem no html tags will be allowed unless the sanitize option is set to true, in that case only the tags [*b i u s a strong em p h1 h2 h3 h4 h5 ul li ol hr pre span img*] will be allowed. If the script is used without the gem and with frameworks other than Rails, then you should make sure you are providing the csrf authenticity params as meta tags and you should always escape undesired html tags such as script, object and so forth.
+
+    <meta name="csrf-param" content="authenticity_token"/>
+    <meta name="csrf-token" content="YOUR UNIQUE TOKEN HERE"/>
+
+##TODO
+
+- Client Side Validation definitions
+- Accepting more than one handler to activate best_in_place fields
+- Specs *(sacrilege!!)*
+
+---
+
+##Changelog
+
+- v.0.1.0 Initial deploy
+- v.0.1.2 Fixing errors in collections (taken value[0] instead of index) and fixing test_app controller responses
+- v.0.1.3 Bug in Rails Helper. Key wrongly considered an Integer.
+- v.0.1.4 Adding two new parameters for further customization urlObject and nilValue and making input update on blur.
+- v.0.1.5 **Attention: this release is not backwards compatible**. Changing params from list to option hash, helper's refactoring,
+  fixing bug with objects inside namespaces, adding feature for passing an external activator handler as param. Adding feature
+  of key ESCAPE for destroying changes before they are made permanent (in inputs and textarea).
+- v.0.1.6-0.1.7 Avoiding request when the input is not modified and allowing the user to not sanitize input data.
+- v.0.1.8 jslint compliant, sanitizing tags in the gem, getting right csrf params, controlling size of textarea (elastic script, for autogrowing textarea)
+
+##Authors, License and Stuff
+
+Code by [Bernat Farrero](http://bernatfarrero.com) from [Itnig Web Services](http://itnig.net) (it was based on the [original project](http://github.com/janv/rest_in_place/) of Jan Varwig) and released under [MIT license](http://www.opensource.org/licenses/mit-license.php).
+
+Many thanks to the contributors: [Roger Campos](http://github.com/rogercampos) and [Jack Senechal](https://github.com/jacksenechal)

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/best_in_place_mongoid.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "best_in_place_mongoid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "best_in_place_mongoid"
+  s.version     = BestInPlaceMongoid::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bernat Farrero", "Bartłomiej Danek"]
+  s.email       = ["bernat@itnig.net", "bartek.danek@gmail.com"]
+  s.homepage    = "http://github.com/bartekd/best_in_place_mongoid"
+  s.summary     = %q{It makes any field in place editable by clicking on it, it works for inputs, textareas, select dropdowns and checkboxes}
+  s.description = %q{BestInPlaceMongoid is a fork of BestInPlace jQuery script and a Rails 3 helper that provide the method best_in_place to display any object field easily editable for the user by just clicking on it. It supports input data, text data, boolean data and custom dropdown data. It works with RESTful controllers.}
+
+  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"]
+
+  s.add_dependency "rails", "~> 3.1.0"
+  s.add_dependency "mongoid", "~> 2.3.3"
+  s.add_dependency "jquery-rails"
+
+  s.add_development_dependency "rspec-rails", "~> 2.7.0"
+  s.add_development_dependency "nokogiri", ">= 1.5.0"
+  s.add_development_dependency "capybara", ">= 1.0.1"
+end

data/lib/assets/javascripts/best_in_place.js

@@ -0,0 +1,481 @@
+/*
+        BestInPlaceMongoid (for jQuery)
+        version: 0.1.0 (01/01/2011)
+        @requires jQuery >= v1.4
+        @requires jQuery.purr to display pop-up windows
+
+        By Bernat Farrero based on the work of Jan Varwig.
+        Examples at http://bernatfarrero.com
+
+        Licensed under the MIT:
+          http://www.opensource.org/licenses/mit-license.php
+
+        Usage:
+
+        Attention.
+        The format of the JSON object given to the select inputs is the following:
+        [["key", "value"],["key", "value"]]
+        The format of the JSON object given to the checkbox inputs is the following:
+        ["falseValue", "trueValue"]
+*/
+
+function BestInPlaceMongoidEditor(e) {
+  this.element = jQuery(e);
+  this.initOptions();
+  this.bindForm();
+  this.initNil();
+  $(this.activator).bind('click', {editor: this}, this.clickHandler);
+}
+
+BestInPlaceMongoidEditor.prototype = {
+  // Public Interface Functions //////////////////////////////////////////////
+
+  activate : function() {
+    var elem = this.isNil ? "" : this.element.html();
+    this.oldValue = elem;
+    $(this.activator).unbind("click", this.clickHandler);
+    this.activateForm();
+  },
+
+  abort : function() {
+    if (this.isNil) this.element.html(this.nil);
+    else            this.element.html(this.oldValue);
+    $(this.activator).bind('click', {editor: this}, this.clickHandler);
+  },
+
+  update : function() {
+    var editor = this;
+    if (this.formType in {"input":1, "textarea":1} && this.getValue() == this.oldValue)
+    { // Avoid request if no change is made
+      this.abort();
+      return true;
+    }
+    this.isNil = false;
+    editor.ajax({
+      "type"       : "post",
+      "dataType"   : "text",
+      "data"       : editor.requestData(),
+      "success"    : function(data){ editor.loadSuccessCallback(data); },
+      "error"      : function(request, error){ editor.loadErrorCallback(request, error); }
+    });
+    if (this.formType == "select") {
+      var value = this.getValue();
+      $.each(this.values, function(i, v) {
+        if (value == v[0]) {
+          editor.element.html(v[1]);
+        }
+      }
+    );
+    } else if (this.formType == "checkbox") {
+      editor.element.html(this.getValue() ? this.values[1] : this.values[0]);
+    } else {
+      editor.element.html(this.getValue() != "" ? this.getValue() : this.nil);
+    }
+  },
+
+  activateForm : function() {
+    alert("The form was not properly initialized. activateForm is unbound");
+  },
+
+  // Helper Functions ////////////////////////////////////////////////////////
+
+  initOptions : function() {
+    // Try parent supplied info
+    var self = this;
+    self.element.parents().each(function(){
+      self.url           = self.url           || jQuery(this).attr("data-url");
+      self.collection    = self.collection    || jQuery(this).attr("data-collection");
+      self.formType      = self.formType      || jQuery(this).attr("data-type");
+      self.objectName    = self.objectName    || jQuery(this).attr("data-object");
+      self.attributeName = self.attributeName || jQuery(this).attr("data-attribute");
+      self.nil           = self.nil           || jQuery(this).attr("data-nil");
+      self.inner_class   = self.inner_class   || jQuery(this).attr("data-inner-class");
+      self.html_attrs    = self.html_attrs    || jQuery(this).attr("data-html-attrs");
+    });
+
+    // Try Rails-id based if parents did not explicitly supply something
+    self.element.parents().each(function(){
+      var res = this.id.match(/^(\w+)_(\d+)$/i);
+      if (res) {
+        self.objectName = self.objectName || res[1];
+      }
+    });
+
+    // Load own attributes (overrides all others)
+    self.url           = self.element.attr("data-url")          || self.url      || document.location.pathname;
+    self.collection    = self.element.attr("data-collection")   || self.collection;
+    self.formType      = self.element.attr("data-type")         || self.formtype || "input";
+    self.objectName    = self.element.attr("data-object")       || self.objectName;
+    self.attributeName = self.element.attr("data-attribute")    || self.attributeName;
+    self.activator     = self.element.attr("data-activator")    || self.element;
+    self.nil           = self.element.attr("data-nil")          || self.nil      || "-";
+    self.inner_class   = self.element.attr("data-inner-class")  || self.inner_class   || null;
+    self.html_attrs    = self.element.attr("data-html-attrs") || self.html_attrs;
+
+    if (!self.element.attr("data-sanitize")) {
+      self.sanitize = true;
+    }
+    else {
+      self.sanitize = (self.element.attr("data-sanitize") == "true");
+    }
+
+    if ((self.formType == "select" || self.formType == "checkbox") && self.collection !== null)
+    {
+      self.values = jQuery.parseJSON(self.collection);
+    }
+  },
+
+  bindForm : function() {
+    this.activateForm = BestInPlaceMongoidEditor.forms[this.formType].activateForm;
+    this.getValue     = BestInPlaceMongoidEditor.forms[this.formType].getValue;
+  },
+
+  initNil: function() {
+    if (this.element.html() == "")
+    {
+      this.isNil = true
+      this.element.html(this.nil)
+    }
+  },
+
+  getValue : function() {
+    alert("The form was not properly initialized. getValue is unbound");
+  },
+
+  // Trim and Strips HTML from text
+  sanitizeValue : function(s) {
+    if (this.sanitize)
+    {
+      var tmp = document.createElement("DIV");
+      tmp.innerHTML = s;
+      s = tmp.textContent || tmp.innerText;
+    }
+   return jQuery.trim(s);
+  },
+
+  /* Generate the data sent in the POST request */
+  requestData : function() {
+    // To prevent xss attacks, a csrf token must be defined as a meta attribute
+    csrf_token = $('meta[name=csrf-token]').attr('content');
+    csrf_param = $('meta[name=csrf-param]').attr('content');
+
+    var data = "_method=put";
+    data += "&" + this.objectName + '[' + this.attributeName + ']=' + encodeURIComponent(this.getValue());
+
+    if (csrf_param !== undefined && csrf_token !== undefined) {
+      data += "&" + csrf_param + "=" + encodeURIComponent(csrf_token);
+    }
+    return data;
+  },
+
+  ajax : function(options) {
+    options.url = this.url;
+    options.beforeSend = function(xhr){ xhr.setRequestHeader("Accept", "application/json"); };
+    return jQuery.ajax(options);
+  },
+
+  // Handlers ////////////////////////////////////////////////////////////////
+
+  loadSuccessCallback : function(data) {
+    this.element.html(data[this.objectName]);
+    this.element.trigger($.Event("ajax:success"), data);
+
+    // Binding back after being clicked
+    $(this.activator).bind('click', {editor: this}, this.clickHandler);
+  },
+
+  loadErrorCallback : function(request, error) {
+    this.element.html(this.oldValue);
+
+    // Display all error messages from server side validation
+    $.each(jQuery.parseJSON(request.responseText), function(index, value) {
+      if( typeof(value) == "object") {value = index + " " + value.toString(); }
+      var container = $("<span class='flash-error'></span>").html(value);
+      container.purr();
+    });
+
+    // Binding back after being clicked
+    $(this.activator).bind('click', {editor: this}, this.clickHandler);
+  },
+
+  clickHandler : function(event) {
+    event.data.editor.activate();
+  },
+
+  setHtmlAttributes : function() {
+    var formField = this.element.find(this.formType);
+    var attrs = jQuery.parseJSON(this.html_attrs);
+    for(var key in attrs){
+      formField.attr(key, attrs[key]);
+    }
+  }
+};
+
+
+BestInPlaceMongoidEditor.forms = {
+  "input" : {
+    activateForm : function() {
+      var output = '<form class="form_in_place" action="javascript:void(0)" style="display:inline;">';
+      output += '<input type="text" name="'+ this.attributeName + '" value="' + this.sanitizeValue(this.oldValue) + '"';
+      if (this.inner_class != null) {
+        output += ' class="' + this.inner_class + '"';
+      }
+      output += '></form>'
+      this.element.html(output);
+      this.setHtmlAttributes();
+      this.element.find('input')[0].select();
+      this.element.find("form").bind('submit', {editor: this}, BestInPlaceMongoidEditor.forms.input.submitHandler);
+      this.element.find("input").bind('blur',   {editor: this}, BestInPlaceMongoidEditor.forms.input.inputBlurHandler);
+      this.element.find("input").bind('keyup', {editor: this}, BestInPlaceMongoidEditor.forms.input.keyupHandler);
+    },
+
+    getValue :  function() {
+      return this.sanitizeValue(this.element.find("input").val());
+    },
+
+    inputBlurHandler : function(event) {
+      event.data.editor.update();
+    },
+
+    submitHandler : function(event) {
+      event.data.editor.update();
+    },
+
+    keyupHandler : function(event) {
+      if (event.keyCode == 27) {
+        event.data.editor.abort();
+      }
+    }
+  },
+
+  "select" : {
+    activateForm : function() {
+      var output = "<form action='javascript:void(0)' style='display:inline;'><select>";
+      var selected = "";
+      var oldValue = this.oldValue;
+      $.each(this.values, function(index, value) {
+        selected = (value[1] == oldValue ? "selected='selected'" : "");
+        output += "<option value='" + value[0] + "' " + selected + ">" + value[1] + "</option>";
+       });
+      output += "</select></form>";
+      this.element.html(output);
+      this.setHtmlAttributes();
+      this.element.find("select").bind('change', {editor: this}, BestInPlaceMongoidEditor.forms.select.blurHandler);
+      this.element.find("select").bind('blur', {editor: this}, BestInPlaceMongoidEditor.forms.select.blurHandler);
+      this.element.find("select").bind('keyup', {editor: this}, BestInPlaceMongoidEditor.forms.select.keyupHandler);
+      this.element.find("select")[0].focus();
+    },
+
+    getValue : function() {
+      return this.sanitizeValue(this.element.find("select").val());
+    },
+
+    blurHandler : function(event) {
+      event.data.editor.update();
+    },
+
+    keyupHandler : function(event) {
+      if (event.keyCode == 27) event.data.editor.abort();
+    }
+  },
+
+  "checkbox" : {
+    activateForm : function() {
+      var newValue = Boolean(this.oldValue != this.values[1]);
+      var output = newValue ? this.values[1] : this.values[0];
+      this.element.html(output);
+      this.setHtmlAttributes();
+      this.update();
+    },
+
+    getValue : function() {
+      return Boolean(this.element.html() == this.values[1]);
+    }
+  },
+
+  "textarea" : {
+    activateForm : function() {
+      // grab width and height of text
+      width = this.element.css('width');
+      height = this.element.css('height');
+
+      // construct the form
+      var output = '<form action="javascript:void(0)" style="display:inline;"><textarea>';
+      output += this.sanitizeValue(this.oldValue);
+      output += '</textarea></form>';
+      this.element.html(output);
+      this.setHtmlAttributes();
+
+      // set width and height of textarea
+      jQuery(this.element.find("textarea")[0]).css({ 'min-width': width, 'min-height': height });
+      jQuery(this.element.find("textarea")[0]).elastic();
+
+      this.element.find("textarea")[0].focus();
+      this.element.find("textarea").bind('blur', {editor: this}, BestInPlaceMongoidEditor.forms.textarea.blurHandler);
+      this.element.find("textarea").bind('keyup', {editor: this}, BestInPlaceMongoidEditor.forms.textarea.keyupHandler);
+    },
+
+    getValue :  function() {
+      return this.sanitizeValue(this.element.find("textarea").val());
+    },
+
+    blurHandler : function(event) {
+      event.data.editor.update();
+    },
+
+    keyupHandler : function(event) {
+      if (event.keyCode == 27) {
+        BestInPlaceMongoidEditor.forms.textarea.abort(event.data.editor);
+      }
+    },
+
+    abort : function(editor) {
+      if (confirm("Are you sure you want to discard your changes?")) {
+        editor.abort();
+      }
+    }
+  }
+};
+
+jQuery.fn.best_in_place = function() {
+  this.each(function(){
+    if (!jQuery(this).data('bestInPlaceEditor')) {
+      jQuery(this).data('bestInPlaceEditor', new BestInPlaceMongoidEditor(this));
+    }
+  });
+  return this;
+};
+
+
+
+/**
+* @name             Elastic
+* @descripton           Elastic is Jquery plugin that grow and shrink your textareas automaticliy
+* @version            1.6.5
+* @requires           Jquery 1.2.6+
+*
+* @author             Jan Jarfalk
+* @author-email         jan.jarfalk@unwrongest.com
+* @author-website         http://www.unwrongest.com
+*
+* @licens             MIT License - http://www.opensource.org/licenses/mit-license.php
+*/
+
+(function(jQuery){
+  jQuery.fn.extend({
+    elastic: function() {
+      //  We will create a div clone of the textarea
+      //  by copying these attributes from the textarea to the div.
+      var mimics = [
+        'paddingTop',
+        'paddingRight',
+        'paddingBottom',
+        'paddingLeft',
+        'fontSize',
+        'lineHeight',
+        'fontFamily',
+        'width',
+        'fontWeight'];
+
+      return this.each( function() {
+
+        // Elastic only works on textareas
+        if ( this.type != 'textarea' ) {
+          return false;
+        }
+
+        var $textarea = jQuery(this),
+          $twin   = jQuery('<div />').css({'position': 'absolute','display':'none','word-wrap':'break-word'}),
+          lineHeight  = parseInt($textarea.css('line-height'),10) || parseInt($textarea.css('font-size'),'10'),
+          minheight = parseInt($textarea.css('height'),10) || lineHeight*3,
+          maxheight = parseInt($textarea.css('max-height'),10) || Number.MAX_VALUE,
+          goalheight  = 0,
+          i       = 0;
+
+        // Opera returns max-height of -1 if not set
+        if (maxheight < 0) { maxheight = Number.MAX_VALUE; }
+
+        // Append the twin to the DOM
+        // We are going to meassure the height of this, not the textarea.
+        $twin.appendTo($textarea.parent());
+
+        // Copy the essential styles (mimics) from the textarea to the twin
+        var i = mimics.length;
+        while(i--){
+          $twin.css(mimics[i].toString(),$textarea.css(mimics[i].toString()));
+        }
+
+
+        // Sets a given height and overflow state on the textarea
+        function setHeightAndOverflow(height, overflow){
+          curratedHeight = Math.floor(parseInt(height,10));
+          if($textarea.height() != curratedHeight){
+            $textarea.css({'height': curratedHeight + 'px','overflow':overflow});
+
+          }
+        }
+
+
+        // This function will update the height of the textarea if necessary
+        function update() {
+
+          // Get curated content from the textarea.
+          var textareaContent = $textarea.val().replace(/&/g,'&amp;').replace(/  /g, '&nbsp;').replace(/<|>/g, '&gt;').replace(/\n/g, '<br />');
+
+          // Compare curated content with curated twin.
+          var twinContent = $twin.html().replace(/<br>/ig,'<br />');
+
+          if(textareaContent+'&nbsp;' != twinContent){
+
+            // Add an extra white space so new rows are added when you are at the end of a row.
+            $twin.html(textareaContent+'&nbsp;');
+
+            // Change textarea height if twin plus the height of one line differs more than 3 pixel from textarea height
+            if(Math.abs($twin.height() + lineHeight - $textarea.height()) > 3){
+
+              var goalheight = $twin.height()+lineHeight;
+              if(goalheight >= maxheight) {
+                setHeightAndOverflow(maxheight,'auto');
+              } else if(goalheight <= minheight) {
+                setHeightAndOverflow(minheight,'hidden');
+              } else {
+                setHeightAndOverflow(goalheight,'hidden');
+              }
+
+            }
+
+          }
+
+        }
+
+        // Hide scrollbars
+        $textarea.css({'overflow':'hidden'});
+
+        // Update textarea size on keyup, change, cut and paste
+        $textarea.bind('keyup change cut paste', function(){
+          update();
+        });
+
+        // Compact textarea on blur
+        // Lets animate this....
+        $textarea.bind('blur',function(){
+          if($twin.height() < maxheight){
+            if($twin.height() > minheight) {
+              $textarea.height($twin.height());
+            } else {
+              $textarea.height(minheight);
+            }
+          }
+        });
+
+        // And this line is to catch the browser paste event
+        $textarea.live('input paste',function(e){ setTimeout( update, 250); });
+
+        // Run update once when elastic is initialized
+        update();
+
+      });
+
+        }
+    });
+})(jQuery);