chore: merge jquery-form history into third-party/projects/

In service of:

    #394

Basically, we want to pull in the code from this third-party project
(which is mostly on life-support at this point) and apply a small patch
on top. We don't anticipate having to change it much, if ever, so we are
sticking it under "third-party/projects/" and we won't cover it with our
normal linting/formatting/testing.

Note that because everything else in the repo pulls in history via
subtree merge, doing it here as well. That way if we ever need to `git
blame` in here we'll have something useful to look at.

Note also that in liferay-portal we are using v3.51 of this plugin and
have no plans to switch to the latest (v4.3.0) at this time, but I am
still pulling in and re-writing all of the tags so that we can easily
merge the newer stuff in in the future if we want to.

Steps follow.

Grab the code:

    git remote add -f jquery-form https://github.com/jquery-form/form.git

Make directory for it. Note that it is going to live at
"third-party/projects/jquery-form/" and not "third-party/jquery-form/";
we want to reserve the top-level inside of "third-party/" for any future
tooling that we might want to share across projects, or any common
READMEs or other docs:

    mkdir -p third-party/projects

Create annotated tags seeing as all the tags in the project are
unannotated:

    for TAG in \
      3.25.0-2013.01.18 \
      3.32.0-2013.04.09 \
      3.36 \
      3.37.0 \
      3.45.0 \
      3.46.0 \
      3.49 \
      3.50 \
      3.51; do
      git tag -f -a -m jquery-form/v$TAG $TAG $TAG
    done

    for TAG in \
      v3.19 \
      v4.0.0 \
      v4.0.1 \
      v4.1.0 \
      v4.2.0 \
      v4.2.1 \
      v4.2.2 \
      v4.3.0; do
      git tag -f -a -m jquery-form/$TAG $TAG $TAG
    done

Rewrite tags to have a prefix. First tags starting with "v" and then
those without a leading "v":

    support/filter-tags.sh jquery-form/master 'sed "s#^v#jquery-form/v#"'
    support/filter-tags.sh jquery-form/master 'sed "s#^\([0-9]\)#jquery-form/v\1#"'

Do the actual subtree merge:

    git merge -s ours --no-commit --allow-unrelated-histories jquery-form/v3.51
    git read-tree --prefix=third-party/projects/jquery-form -u jquery-form/v3.51
    git commit -m 'chore: merge jquery-form history into third-party/projects/'

Make sure shape of DAG is sane:

    git log --oneline --decorate --graph --all

Push rewritten tags so that entire history will be reachable/explorable:

    git push upstream-rw --tags --dry-run
    git push upstream-rw --tags

Kill temporary remote that was added earlier. We don't want this lying
around because a careless `fetch` could pull down all the tags that we
don't want (because they aren't prefixed, or annotated, or even
consistent), and it is all too easy to accidentally contaminate the
upstream with these tags by a push. If we ever need to resync with
upstream history again, we can just re-add the remote:

    git remote remove jquery-form

Amend commit to make these notes that you're reading now:

    git commit --amend

Author: wincent

third-party/projects/jquery-form/README.md

@@ -0,0 +1,208 @@
+#[jQuery Form Plugin](http://jquery.malsup.com/form/)
+
+##Overview
+The jQuery Form Plugin allows you to easily and unobtrusively upgrade HTML forms to use AJAX.  The main methods, ajaxForm and ajaxSubmit, gather information from the form element to determine how to manage the submit process. Both of these methods support numerous options which allows you to have full control over how the data is submitted. 
+
+No special markup is needed, just a normal form.  Submitting a form with AJAX doesn't get any easier than this!
+
+---
+ 
+##API
+
+###jqXHR
+The jqXHR object is stored in element <em>data</em>-cache with the <code>jqxhr</code> key after each <code>ajaxSubmit</code>
+call.  It can be accessed like this:
+````javascript
+var form = $('#myForm').ajaxSubmit({ /* options */ });
+var xhr = form.data('jqxhr');
+
+xhr.done(function() {
+...
+});
+````
+
+###ajaxForm( options )
+Prepares a form to be submitted via AJAX by adding all of the necessary event listeners. It does **not** submit the form. Use `ajaxForm` in your document's `ready` function to prepare existing forms for AJAX submission, or with the `delegation` option to handle forms not yet added to the DOM.  
+Use ajaxForm when you want the plugin to manage all the event binding for you.
+
+````javascript
+// prepare all forms for ajax submission
+$('form').ajaxForm({
+	target: '#myResultsDiv'
+});
+````
+
+###ajaxSubmit( options )
+Immediately submits the form via AJAX. In the most common use case this is invoked in response to the user clicking a submit button on the form. 
+Use ajaxSubmit if you want to bind your own submit handler to the form.
+
+````javascript
+// bind submit handler to form
+$('form').on('submit', function(e) {
+	e.preventDefault(); // prevent native submit
+	$(this).ajaxSubmit({
+		target: 'myResultsDiv'
+	})
+});
+````
+
+---
+
+##Options
+Note: all standard [$.ajax](http://api.jquery.com/jQuery.ajax) options can be used.
+
+###beforeSerialize
+Callback function invoked prior to form serialization.  Provides an opportunity to manipulate the form before its values are retrieved.  Returning `false` from the callback will prevent the form from being submitted.  The callback is invoked with two arguments: the jQuery wrapped form object and the options object.
+
+````javascript
+beforeSerialize: function($form, options) { 
+    // return false to cancel submit                  
+}
+````
+
+###beforeSubmit
+Callback function invoked prior to form submission.  This provides an opportunity to manipulate the form before it's values are retrieved.  Returning `false` from the callback will prevent the form from being submitted.  The callback is invoked with three arguments: the form data in array format, the jQuery wrapped form object, and the options Oobject.
+
+````javascript
+beforeSubmit: function(arr, $form, options) { 
+    // form data array is an array of objects with name and value properties
+    // [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ] 
+	// return false to cancel submit                  
+}
+````
+
+###clearForm
+Boolean flag indicating whether the form should be cleared if the submit is successful
+
+###data
+An object containing extra data that should be submitted along with the form.
+
+````javascript
+data: { key1: 'value1', key2: 'value2' }
+````
+
+###dataType
+Expected data type of the response. One of: null, 'xml', 'script', or 'json'. The dataType option provides a means for specifying how the server response should be handled. This maps directly to jQuery's dataType method. The following values are supported:
+
+* 'xml': server response is treated as XML and the 'success' callback method, if specified, will be passed the responseXML value
+* 'json': server response will be evaluted and passed to the 'success' callback, if specified
+* 'script': server response is evaluated in the global context
+
+###delegation
+true to enable support for event delegation
+*requires jQuery v1.7+*
+
+````javascript
+// prepare all existing and future forms for ajax submission
+$('form').ajaxForm({
+    delegation: true
+});
+````
+
+###error
+Callback function to be invoked upon error.
+
+###forceSync
+Only applicable when explicity using the iframe option or when uploading files on browses that don't support XHR2.
+Set to `true` to remove the short delay before posting form when uploading files. The delay is used to allow the browser to render DOM updates prior to performing a native form submit. This improves usability when displaying notifications to the user, such as "Please Wait..." 
+
+###iframe
+Boolean flag indicating whether the form should *always* target the server response to an iframe instead of leveraging XHR when possible.
+
+###iframeSrc
+String value that should be used for the iframe's src attribute when/if an iframe is used.
+
+###iframeTarget
+Identifies the iframe element to be used as the response target for file uploads. By default, the plugin will create a temporary iframe element to capture the response when uploading files. This options allows you to use an existing iframe if you wish. When using this option the plugin will make no attempt at handling the response from the server.
+
+###replaceTarget
+Optionally used along with the the target option. Set to true if the target should be replaced or false if only the target contents should be replaced. 
+
+###resetForm
+Boolean flag indicating whether the form should be reset if the submit is successful
+
+###semantic
+Boolean flag indicating whether data must be submitted in strict semantic order (slower). Note that the normal form serialization is done in semantic order with the exception of input elements of `type="image"`. You should only set the semantic option to true if your server has strict semantic requirements and your form contains an input element of `type="image"`.
+
+###success
+Callback function to be invoked after the form has been submitted. If a `success` callback function is provided it is invoked after the response has been returned from the server.  It is passed the following arguments:
+
+1. responseText or responseXML value (depending on the value of the dataType option).
+2. statusText
+3. xhr (or the jQuery-wrapped form element if using jQuery < 1.4)
+4. jQuery-wrapped form element (or undefined if using jQuery < 1.4)
+
+###target
+Identifies the element(s) in the page to be updated with the server response. This value may be specified as a jQuery selection string, a jQuery object, or a DOM element.
+
+###type
+The method in which the form data should be submitted, 'GET' or 'POST'.
+
+###uploadProgress
+Callback function to be invoked with upload progress information (if supported by the browser). The callback is passed the following arguments:
+
+1. event; the browser event
+2. position (integer)
+3. total (integer)
+4. percentComplete (integer)
+
+###url
+URL to which the form data will be submitted.
+
+---
+
+##Utility Methods
+###formSerialize
+Serializes the form into a query string. This method will return a string in the format: `name1=value1&name2=value2`
+
+````javascript
+var queryString = $('#myFormId').formSerialize();
+````
+
+###fieldSerialize
+Serializes field elements into a query string. This is handy when you need to serialize only part of a form. This method will return a string in the format: `name1=value1&name2=value2`
+
+````javascript
+var queryString = $('#myFormId .specialFields').fieldSerialize();
+````
+
+###fieldValue
+Returns the value(s) of the element(s) in the matched set in an array.  This method always returns an array.  If no valid value can be determined the array will be empty, otherwise it will contain one or more values.
+
+###resetForm
+Resets the form to its original state by invoking the form element's native DOM method.
+
+###clearForm
+Clears the form elements. This method emptys all of the text inputs, password inputs and textarea elements, clears the selection in any select elements, and unchecks all radio and checkbox inputs.  It does *not* clear hidden field values.
+
+###clearFields
+Clears selected field elements. This is handy when you need to clear only a part of the form.
+
+---
+
+##File Uploads
+The Form Plugin supports use of [XMLHttpRequest Level 2]("http://www.w3.org/TR/XMLHttpRequest/") and [FormData](https://developer.mozilla.org/en/XMLHttpRequest/FormData) objects on browsers that support these features.  As of today (March 2012) that includes Chrome, Safari, and Firefox.  On these browsers (and future Opera and IE10) files uploads will occur seamlessly through the XHR object and progress updates are available as the upload proceeds.  For older browsers, a fallback technology is used which involves iframes.  [More Info](http://malsup.com/jquery/form/#file-upload)
+
+---
+
+##CDN Support
+`<script src="//oss.maxcdn.com/jquery.form/3.50/jquery.form.min.js"></script>`
+
+##Copyright and License
+Copyright 2006-2013 (c) M. Alsup
+
+All versions, present and past, of the jQuery Form plugin are dual licensed under the MIT and GPL licenses:
+
+* [MIT](http://malsup.github.com/mit-license.txt)
+* [GPL](http://malsup.github.com/gpl-license-v2.txt)
+
+You may use either license.  The MIT License is recommended for most projects because it is simple and easy to understand and it places almost no restrictions on what you can do with the plugin.
+
+If the GPL suits your project better you are also free to use the plugin under that license.
+
+You don't have to do anything special to choose one license or the other and you don't have to notify anyone which license you are using. You are free to use the jQuery Form Plugin in commercial projects as long as the copyright header is left intact.
+
+
+---
+
+Additional documentation and examples at: http://malsup.com/jquery/form/

third-party/projects/jquery-form/bower.json

@@ -0,0 +1,15 @@
+{
+  "name": "jquery-form",
+  "version": "3.51.0",
+  "main": "jquery.form.js",
+  "author": "M. Alsup",
+  "dependencies": {
+    "jquery": ">=1.5"
+  },
+  "ignore": [
+    "README.md",
+    "composer.json",
+    "form.jquery.json",
+    "package.json"
+  ]
+}

third-party/projects/jquery-form/composer.json

@@ -0,0 +1,40 @@
+{
+  "name": "malsup/form",
+  "description": "A simple way to AJAX-ify any form on your page; with file upload and progress support.",
+  "type": "component",
+  "homepage": "http://jquery.malsup.com/form/",
+  "keywords": [
+    "form",
+    "upload",
+    "ajax"
+  ],
+  "support": {
+    "issues": "https://github.com/malsup/form/issues",
+    "wiki": "http://jquery.malsup.com/form/"
+  },
+  "authors": [
+    {
+      "name": "M. Alsup",
+      "homepage": "http://jquery.malsup.com"
+    }
+  ],
+  "license": [
+    "MIT",
+    "GPL-2.0"
+  ],
+  "require": {
+    "components/jquery": ">=1.5"
+  },
+  "extra": {
+    "component": {
+      "scripts": [
+        "jquery.form.js"
+      ],
+      "shim": {
+        "deps": [
+          "jquery"
+        ]
+      }
+    }
+  }
+}

third-party/projects/jquery-form/form.jquery.json

@@ -0,0 +1,33 @@
+{
+  "name": "form",
+  "title": "Form",
+  "description": "A simple way to AJAX-ify any form on your page; with file upload and progress support.",
+  "keywords": [
+    "form",
+    "upload",
+    "ajax"
+  ],
+  "version": "3.51.0",
+  "author": {
+    "name": "M. Alsup",
+    "url": "http://jquery.malsup.com"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://malsup.github.com/mit-license.txt"
+    },
+    {
+      "type": "GPL",
+      "url": "http://malsup.github.com/gpl-license-v2.txt"
+    }
+  ],
+  "bugs": "https://github.com/malsup/form/issues",
+  "homepage": "http://jquery.malsup.com/form/",
+  "docs": "http://jquery.malsup.com/form/",
+  "download": "http://malsup.github.com/jquery.form.js",
+  "dependencies": {
+    "jquery": ">=1.5"
+  }
+}
+

third-party/projects/jquery-form/gulpfile.js

@@ -0,0 +1,18 @@
+/* buildfile for jquery.form plugin */
+var gulp = require('gulp'),
+  concat = require('gulp-concat'),
+  jshint = require('gulp-jshint'),
+  uglify = require('gulp-uglify');
+
+gulp.task('default', function() {
+  gulp.src(['jquery.form.js'])
+    .pipe(jshint())
+    .pipe(jshint.reporter('default'))
+    .pipe(uglify({ preserveComments: 'some' }))
+    .pipe(concat('jquery.form.min.js'))
+    .pipe(gulp.dest('.'));
+});
+
+gulp.task('watch', function () {
+  gulp.watch('jquery.form.js', ['default']);
+});