├── .editorconfig
├── .gitignore
├── .travis.yml
├── .zuul.yml
├── History.md
├── LICENSE
├── README.md
├── index.js
├── package.json
└── test
    └── index.js


/.editorconfig:
--------------------------------------------------------------------------------
1 | [*.js]
2 | indent_style = space
3 | indent_size = 4
4 | insert_final_newline = true
5 | max_line_length = 80
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | lib-cov
 2 | *.seed
 3 | *.log
 4 | *.csv
 5 | *.dat
 6 | *.out
 7 | *.pid
 8 | *.gz
 9 | 
10 | pids
11 | logs
12 | results
13 | 
14 | npm-debug.log
15 | node_modules
16 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 | - '5'
4 | env:
5 |   global:
6 |   - secure: QHQz/F+IvYyRkgrVEEc3NTsfkJwXlzsU8jACVIPbhHVOaaDe97b/tk0A4vv+eo+BXVNhyio7ojLlOnlcY0eiHKc31frf/Rv4nARzdG+EmzRuBtpxsnchQ92RzKhL+hL57p0LLvTW3yPAJX44lTnI8WrbvuUA22rphm0YsD1yaLM=
7 |   - secure: exf51mpyUBQeesvMOpIrKWI/SoiSBmc8TK5Jw+npDmjLUWZl0ou4Ptg0vUqhIjoKM/mvrAnOcTIeSqrK5+Kngy9gRrYJxJjjNARphIZA3LQtyvbDGvMoJXooare6DmYCLf3r/YVN3SAE2yfkpE4fvJHrugsD2Ch4RX618ZdqzbI=
8 | 


--------------------------------------------------------------------------------
/.zuul.yml:
--------------------------------------------------------------------------------
 1 | ui: mocha-qunit
 2 | browsers:
 3 |   - name: chrome
 4 |     version: latest
 5 |   - name: firefox
 6 |     version: latest
 7 |   - name: safari
 8 |     version: 5..latest
 9 |   - name: ie
10 |     version: 9..latest
11 |   - name: iphone
12 |     version: latest
13 |   - name: android
14 |     version: latest
15 | 


--------------------------------------------------------------------------------
/History.md:
--------------------------------------------------------------------------------
 1 | # 0.7.2 (2017-06-11)
 2 | 
 3 | * Serialize properly radio input with empty value (1b7a042)
 4 | 
 5 | # 0.7.1 (2016-03-11)
 6 | 
 7 | * fix bracket notation number parsing (de5d19)
 8 | 
 9 | # 0.7.0 (2015-10-17)
10 | 
11 | * add bracket notation support for hash serialization
12 | 
13 | # 0.6.0 (2015-02-23)
14 | 
15 | * add options.empty to force serialize empty inputs
16 | 
17 | # 0.5.0 (2015-02-08)
18 | 
19 | * fix specifying custom serializer
20 | 
21 | # 0.4.1 (2015-01-15)
22 | 
23 | * fix nested [][] serialization
24 | 
25 | # 0.4.0 (2014-12-16)
26 | 
27 | * consistently serialize [] params into arrays
28 | * fix multi-select field support
29 | 
30 | # 0.3.0 / 2014-05-01
31 | 
32 | * support bracket notation for hash serialization
33 | 
34 | # 0.2.0 / 2013-12-05
35 | 
36 | * add `disabled` option to include disabled fields
37 | 
38 | # 0.1.1 / 2013-08-26
39 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2013 Roman Shtylman
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # form-serialize [![Build Status](https://travis-ci.org/defunctzombie/form-serialize.png?branch=master)](https://travis-ci.org/defunctzombie/form-serialize)
  2 | 
  3 | serialize form fields to submit a form over ajax
  4 | 
  5 | ## install
  6 | 
  7 | ```shell
  8 | npm install form-serialize
  9 | ```
 10 | 
 11 | ## use
 12 | 
 13 | form-serialize supports two output formats, url encoded (default) or hash (js objects).
 14 | 
 15 | Lets serialize the following html form:
 16 | ```html
 17 | <form id="example-form">
 18 | 	<input type="text" name="foo" value="bar"/>
 19 | 	<input type="submit" value="do it!"/>
 20 | </form>
 21 | ```
 22 | 
 23 | ```js
 24 | var serialize = require('form-serialize');
 25 | var form = document.querySelector('#example-form');
 26 | 
 27 | var str = serialize(form);
 28 | // str -> "foo=bar"
 29 | 
 30 | var obj = serialize(form, { hash: true });
 31 | // obj -> { foo: 'bar' }
 32 | ```
 33 | 
 34 | ## api
 35 | 
 36 | ### serialize(form [, options])
 37 | 
 38 | Returns a serialized form of a HTMLForm element. Output is determined by the serializer used. Default serializer is url-encoded.
 39 | 
 40 | arg | type | desc
 41 | :--- | :--- | :---
 42 | form | HTMLForm | must be an HTMLForm element
 43 | options | Object | optional options object
 44 | 
 45 | #### options
 46 | 
 47 | option | type | default | desc
 48 | :--- | :--- | :---: | :---
 49 | hash | boolean | false | if `true`, the hash serializer will be used for `serializer` option
 50 | serializer | function | url-encoding | override the default serializer (hash or url-encoding)
 51 | disabled | boolean | false | if `true`, disabled fields will also be serialized
 52 | empty | boolean | false | if `true`, empty fields will also be serialized
 53 | 
 54 | ### custom serializer
 55 | 
 56 | Serializers take 3 arguments: `result`, `key`, `value` and should return a newly updated result.
 57 | 
 58 | See the example serializers in the index.js source file.
 59 | 
 60 | ## notes
 61 | 
 62 | only [successful control](http://www.w3.org/TR/html401/interact/forms.html#h-17.13.2) form fields are serialized (with the exception of disabled fields if disabled option is set)
 63 | 
 64 | multiselect fields with more than one value will result in an array of values in the `hash` output mode using the default hash serializer
 65 | 
 66 | ### explicit array fields
 67 | 
 68 | Fields who's name ends with `[]` are **always** serialized as an array field in `hash` output mode using the default hash serializer.
 69 | The field name also gets the brackets removed from its name.
 70 | 
 71 | This does not affect `url-encoding` mode output in any way.
 72 | 
 73 | ```html
 74 | <form id="example-form">
 75 | 	<input type="checkbox" name="foo[]" value="bar" checked />
 76 | 	<input type="checkbox" name="foo[]" value="baz" />
 77 | 	<input type="submit" value="do it!"/>
 78 | </form>
 79 | ```
 80 | 
 81 | ```js
 82 | var serialize = require('form-serialize');
 83 | var form = document.querySelector('#example-form');
 84 | 
 85 | var obj = serialize(form, { hash: true });
 86 | // obj -> { foo: ['bar'] }
 87 | 
 88 | var str = serialize(form);
 89 | // str -> "foo[]=bar"
 90 | 
 91 | ```
 92 | 
 93 | ### indexed arrays
 94 | 
 95 | Adding numbers between brackets for the array notation above will result in a hash serialization with explicit ordering based on the index number regardless of element ordering.
 96 | 
 97 | Like the "[explicit array fields](explicit-array-fields)" this does not affect url-encoding mode output in any way.
 98 | 
 99 | ```html
100 | <form id="todos-form">
101 | 	<input type="text" name="todos[1]" value="milk" />
102 | 	<input type="text" name="todos[0]" value="eggs" />
103 | 	<input type="text" name="todos[2]" value="flour" />
104 | </form>
105 | ```
106 | 
107 | ```js
108 | var serialize = require('form-serialize');
109 | var form = document.querySelector('#todos-form');
110 | 
111 | var obj = serialize(form, { hash: true });
112 | // obj -> { todos: ['eggs', 'milk', 'flour'] }
113 | 
114 | var str = serialize(form);
115 | // str -> "todos[1]=milk&todos[0]=eggs&todos[2]=flour"
116 | 
117 | ```
118 | 
119 | ### nested objects
120 | 
121 | Similar to the indexed array notation, attribute names can be added by inserting a string value between brackets. The notation can be used to create deep objects and mixed with the array notation.
122 | 
123 | Like the "[explicit array fields](explicit-array-fields)" this does not affect url-encoding mode output.
124 | 
125 | ```html
126 | <form id="nested-example">
127 | 	<input type="text" name="foo[bar][baz]" value="qux" />
128 | 	<input type="text" name="foo[norf][]" value="item 1" />
129 | </form>
130 | ```
131 | 
132 | ```js
133 | var serialize = require('form-serialize');
134 | var form = document.querySelector('#todos-form');
135 | 
136 | var obj = serialize(form, { hash: true });
137 | // obj -> { foo: { bar: { baz: 'qux' } }, norf: [ 'item 1' ] }
138 | 
139 | ```
140 | 
141 | ## references
142 | 
143 | This module is based on ideas from jQuery serialize and the Form.serialize method from the prototype library
144 | 
145 | ## license
146 | 
147 | MIT
148 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | // get successful control from form and assemble into object
  2 | // http://www.w3.org/TR/html401/interact/forms.html#h-17.13.2
  3 | 
  4 | // types which indicate a submit action and are not successful controls
  5 | // these will be ignored
  6 | var k_r_submitter = /^(?:submit|button|image|reset|file)$/i;
  7 | 
  8 | // node names which could be successful controls
  9 | var k_r_success_contrls = /^(?:input|select|textarea|keygen)/i;
 10 | 
 11 | // Matches bracket notation.
 12 | var brackets = /(\[[^\[\]]*\])/g;
 13 | 
 14 | // serializes form fields
 15 | // @param form MUST be an HTMLForm element
 16 | // @param options is an optional argument to configure the serialization. Default output
 17 | // with no options specified is a url encoded string
 18 | //    - hash: [true | false] Configure the output type. If true, the output will
 19 | //    be a js object.
 20 | //    - serializer: [function] Optional serializer function to override the default one.
 21 | //    The function takes 3 arguments (result, key, value) and should return new result
 22 | //    hash and url encoded str serializers are provided with this module
 23 | //    - disabled: [true | false]. If true serialize disabled fields.
 24 | //    - empty: [true | false]. If true serialize empty fields
 25 | function serialize(form, options) {
 26 |     if (typeof options != 'object') {
 27 |         options = { hash: !!options };
 28 |     }
 29 |     else if (options.hash === undefined) {
 30 |         options.hash = true;
 31 |     }
 32 | 
 33 |     var result = (options.hash) ? {} : '';
 34 |     var serializer = options.serializer || ((options.hash) ? hash_serializer : str_serialize);
 35 | 
 36 |     var elements = form && form.elements ? form.elements : [];
 37 | 
 38 |     //Object store each radio and set if it's empty or not
 39 |     var radio_store = Object.create(null);
 40 | 
 41 |     for (var i=0 ; i<elements.length ; ++i) {
 42 |         var element = elements[i];
 43 | 
 44 |         // ingore disabled fields
 45 |         if ((!options.disabled && element.disabled) || !element.name) {
 46 |             continue;
 47 |         }
 48 |         // ignore anyhting that is not considered a success field
 49 |         if (!k_r_success_contrls.test(element.nodeName) ||
 50 |             k_r_submitter.test(element.type)) {
 51 |             continue;
 52 |         }
 53 | 
 54 |         var key = element.name;
 55 |         var val = element.value;
 56 | 
 57 |         // we can't just use element.value for checkboxes cause some browsers lie to us
 58 |         // they say "on" for value when the box isn't checked
 59 |         if ((element.type === 'checkbox' || element.type === 'radio') && !element.checked) {
 60 |             val = undefined;
 61 |         }
 62 | 
 63 |         // If we want empty elements
 64 |         if (options.empty) {
 65 |             // for checkbox
 66 |             if (element.type === 'checkbox' && !element.checked) {
 67 |                 val = '';
 68 |             }
 69 | 
 70 |             // for radio
 71 |             if (element.type === 'radio') {
 72 |                 if (!radio_store[element.name] && !element.checked) {
 73 |                     radio_store[element.name] = false;
 74 |                 }
 75 |                 else if (element.checked) {
 76 |                     radio_store[element.name] = true;
 77 |                 }
 78 |             }
 79 | 
 80 |             // if options empty is true, continue only if its radio
 81 |             if (val == undefined && element.type == 'radio') {
 82 |                 continue;
 83 |             }
 84 |         }
 85 |         else {
 86 |             // value-less fields are ignored unless options.empty is true
 87 |             if (!val) {
 88 |                 continue;
 89 |             }
 90 |         }
 91 | 
 92 |         // multi select boxes
 93 |         if (element.type === 'select-multiple') {
 94 |             val = [];
 95 | 
 96 |             var selectOptions = element.options;
 97 |             var isSelectedOptions = false;
 98 |             for (var j=0 ; j<selectOptions.length ; ++j) {
 99 |                 var option = selectOptions[j];
100 |                 var allowedEmpty = options.empty && !option.value;
101 |                 var hasValue = (option.value || allowedEmpty);
102 |                 if (option.selected && hasValue) {
103 |                     isSelectedOptions = true;
104 | 
105 |                     // If using a hash serializer be sure to add the
106 |                     // correct notation for an array in the multi-select
107 |                     // context. Here the name attribute on the select element
108 |                     // might be missing the trailing bracket pair. Both names
109 |                     // "foo" and "foo[]" should be arrays.
110 |                     if (options.hash && key.slice(key.length - 2) !== '[]') {
111 |                         result = serializer(result, key + '[]', option.value);
112 |                     }
113 |                     else {
114 |                         result = serializer(result, key, option.value);
115 |                     }
116 |                 }
117 |             }
118 | 
119 |             // Serialize if no selected options and options.empty is true
120 |             if (!isSelectedOptions && options.empty) {
121 |                 result = serializer(result, key, '');
122 |             }
123 | 
124 |             continue;
125 |         }
126 | 
127 |         result = serializer(result, key, val);
128 |     }
129 | 
130 |     // Check for all empty radio buttons and serialize them with key=""
131 |     if (options.empty) {
132 |         for (var key in radio_store) {
133 |             if (!radio_store[key]) {
134 |                 result = serializer(result, key, '');
135 |             }
136 |         }
137 |     }
138 | 
139 |     return result;
140 | }
141 | 
142 | function parse_keys(string) {
143 |     var keys = [];
144 |     var prefix = /^([^\[\]]*)/;
145 |     var children = new RegExp(brackets);
146 |     var match = prefix.exec(string);
147 | 
148 |     if (match[1]) {
149 |         keys.push(match[1]);
150 |     }
151 | 
152 |     while ((match = children.exec(string)) !== null) {
153 |         keys.push(match[1]);
154 |     }
155 | 
156 |     return keys;
157 | }
158 | 
159 | function hash_assign(result, keys, value) {
160 |     if (keys.length === 0) {
161 |         result = value;
162 |         return result;
163 |     }
164 | 
165 |     var key = keys.shift();
166 |     var between = key.match(/^\[(.+?)\]$/);
167 | 
168 |     if (key === '[]') {
169 |         result = result || [];
170 | 
171 |         if (Array.isArray(result)) {
172 |             result.push(hash_assign(null, keys, value));
173 |         }
174 |         else {
175 |             // This might be the result of bad name attributes like "[][foo]",
176 |             // in this case the original `result` object will already be
177 |             // assigned to an object literal. Rather than coerce the object to
178 |             // an array, or cause an exception the attribute "_values" is
179 |             // assigned as an array.
180 |             result._values = result._values || [];
181 |             result._values.push(hash_assign(null, keys, value));
182 |         }
183 | 
184 |         return result;
185 |     }
186 | 
187 |     // Key is an attribute name and can be assigned directly.
188 |     if (!between) {
189 |         result[key] = hash_assign(result[key], keys, value);
190 |     }
191 |     else {
192 |         var string = between[1];
193 |         // +var converts the variable into a number
194 |         // better than parseInt because it doesn't truncate away trailing
195 |         // letters and actually fails if whole thing is not a number
196 |         var index = +string;
197 | 
198 |         // If the characters between the brackets is not a number it is an
199 |         // attribute name and can be assigned directly.
200 |         if (isNaN(index)) {
201 |             result = result || {};
202 |             result[string] = hash_assign(result[string], keys, value);
203 |         }
204 |         else {
205 |             result = result || [];
206 |             result[index] = hash_assign(result[index], keys, value);
207 |         }
208 |     }
209 | 
210 |     return result;
211 | }
212 | 
213 | // Object/hash encoding serializer.
214 | function hash_serializer(result, key, value) {
215 |     var matches = key.match(brackets);
216 | 
217 |     // Has brackets? Use the recursive assignment function to walk the keys,
218 |     // construct any missing objects in the result tree and make the assignment
219 |     // at the end of the chain.
220 |     if (matches) {
221 |         var keys = parse_keys(key);
222 |         hash_assign(result, keys, value);
223 |     }
224 |     else {
225 |         // Non bracket notation can make assignments directly.
226 |         var existing = result[key];
227 | 
228 |         // If the value has been assigned already (for instance when a radio and
229 |         // a checkbox have the same name attribute) convert the previous value
230 |         // into an array before pushing into it.
231 |         //
232 |         // NOTE: If this requirement were removed all hash creation and
233 |         // assignment could go through `hash_assign`.
234 |         if (existing) {
235 |             if (!Array.isArray(existing)) {
236 |                 result[key] = [ existing ];
237 |             }
238 | 
239 |             result[key].push(value);
240 |         }
241 |         else {
242 |             result[key] = value;
243 |         }
244 |     }
245 | 
246 |     return result;
247 | }
248 | 
249 | // urlform encoding serializer
250 | function str_serialize(result, key, value) {
251 |     // encode newlines as \r\n cause the html spec says so
252 |     value = value.replace(/(\r)?\n/g, '\r\n');
253 |     value = encodeURIComponent(value);
254 | 
255 |     // spaces should be '+' rather than '%20'.
256 |     value = value.replace(/%20/g, '+');
257 |     return result + (result ? '&' : '') + encodeURIComponent(key) + '=' + value;
258 | }
259 | 
260 | module.exports = serialize;
261 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "form-serialize",
 3 |   "version": "0.7.2",
 4 |   "description": "serialize html forms",
 5 |   "main": "index.js",
 6 |   "directories": {
 7 |     "test": "test"
 8 |   },
 9 |   "devDependencies": {
10 |     "domify": "~1.4.0",
11 |     "zuul": "~3.10.1"
12 |   },
13 |   "scripts": {
14 |     "test": "zuul -- test/index.js",
15 |     "test-local": "zuul --local -- test/index.js"
16 |   },
17 |   "repository": {
18 |     "type": "git",
19 |     "url": "git://github.com/shtylman/form-serialize.git"
20 |   },
21 |   "keywords": [
22 |     "form",
23 |     "serialize"
24 |   ],
25 |   "author": "Roman Shtylman <shtylman@gmail.com>",
26 |   "license": "MIT",
27 |   "bugs": {
28 |     "url": "https://github.com/shtylman/form-serialize/issues"
29 |   }
30 | }


--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
  1 | var assert = require('assert');
  2 | var domify = require('domify');
  3 | 
  4 | var serialize = require('../');
  5 | 
  6 | var hash_check = function(form, exp) {
  7 |     assert.deepEqual(serialize(form, { hash: true }), exp);
  8 | };
  9 | 
 10 | var str_check = function(form, exp) {
 11 |     assert.equal(serialize(form), exp);
 12 | };
 13 | 
 14 | var disabled_check = function(form, exp) {
 15 |     assert.deepEqual(serialize(form, { hash : false, disabled: true }), exp);
 16 | };
 17 | 
 18 | var empty_check = function(form, exp) {
 19 |     assert.deepEqual(serialize(form, { hash : false, disabled: true, empty: true }), exp);
 20 | };
 21 | 
 22 | var empty_check_hash = function(form, exp) {
 23 |     assert.deepEqual(serialize(form, { hash : true, disabled: true, empty: true }), exp);
 24 | };
 25 | 
 26 | test('null form', function() {
 27 |     hash_check(null, {});
 28 |     str_check(null, '');
 29 |     empty_check(null, '');
 30 |     empty_check_hash(null, {});
 31 | });
 32 | 
 33 | test('bad form', function() {
 34 |     var form = {};
 35 |     hash_check(form, {});
 36 |     str_check(form, '');
 37 |     empty_check(form, '');
 38 |     empty_check_hash(form, {});
 39 | });
 40 | 
 41 | test('empty form', function() {
 42 |     var form = domify('<form></form>');
 43 |     hash_check(form, {});
 44 |     str_check(form, '');
 45 |     empty_check(form, '');
 46 |     empty_check_hash(form, {});
 47 | });
 48 | 
 49 | // basic form with single input
 50 | test('single element', function() {
 51 |     var form = domify('<form><input type="text" name="foo" value="bar"/></form>');
 52 |     hash_check(form, {
 53 |         'foo': 'bar'
 54 |     });
 55 |     str_check(form, 'foo=bar');
 56 |     empty_check(form, 'foo=bar');
 57 |     empty_check_hash(form, {
 58 |         'foo': 'bar'
 59 |     });
 60 | });
 61 | 
 62 | test('ignore no value', function() {
 63 |     var form = domify('<form><input type="text" name="foo"/></form>');
 64 |     hash_check(form, {});
 65 |     str_check(form, '');
 66 | });
 67 | 
 68 | test('do not ignore no value when empty option', function() {
 69 |     var form = domify('<form><input type="text" name="foo"/></form>');
 70 |     empty_check(form, 'foo=');
 71 |     empty_check_hash(form, {
 72 |         'foo': ''
 73 |     });
 74 | });
 75 | 
 76 | test('multi inputs', function() {
 77 |     var form = domify('<form>' +
 78 |         '<input type="text" name="foo" value="bar 1"/>' +
 79 |         '<input type="text" name="foo.bar" value="bar 2"/>' +
 80 |         '<input type="text" name="baz.foo" value="bar 3"/>' +
 81 |         '</form>');
 82 |     hash_check(form, {
 83 |         'foo': 'bar 1',
 84 |         'foo.bar': 'bar 2',
 85 |         'baz.foo': 'bar 3'
 86 |     });
 87 |     str_check(form, 'foo=bar+1&foo.bar=bar+2&baz.foo=bar+3');
 88 | });
 89 | 
 90 | test('handle disabled', function() {
 91 |     var form = domify('<form>' +
 92 |         '<input type="text" name="foo" value="bar 1"/>' +
 93 |         '<input type="text" name="foo.bar" value="bar 2" disabled/>' +
 94 |         '</form>');
 95 |     hash_check(form, {
 96 |         'foo': 'bar 1'
 97 |     });
 98 |     str_check(form, 'foo=bar+1');
 99 |     disabled_check(form, 'foo=bar+1&foo.bar=bar+2');
100 | });
101 | 
102 | test('handle disabled and empty', function() {
103 |     var form = domify('<form>' +
104 |         '<input type="text" name="foo" value=""/>' +
105 |         '<input type="text" name="foo.bar" value="" disabled/>' +
106 |         '</form>');
107 |     hash_check(form, {});
108 |     str_check(form, '');
109 |     disabled_check(form, '');
110 |     empty_check(form, 'foo=&foo.bar=');
111 |     empty_check_hash(form, {
112 |         'foo': '',
113 |         'foo.bar': ''
114 |     });
115 | });
116 | 
117 | test('ignore buttons', function() {
118 |     var form = domify('<form>' +
119 |         '<input type="submit" name="foo" value="submit"/>' +
120 |         '<input type="reset" name="foo.bar" value="reset"/>' +
121 |         '</form>');
122 |     hash_check(form, {});
123 |     str_check(form, '');
124 | });
125 | 
126 | test('checkboxes', function() {
127 |     var form = domify('<form>' +
128 |         '<input type="checkbox" name="foo" checked/>' +
129 |         '<input type="checkbox" name="bar"/>' +
130 |         '<input type="checkbox" name="baz" checked/>' +
131 |         '</form>');
132 |     hash_check(form, {
133 |         'foo': "on",
134 |         'baz': "on"
135 |     });
136 |     str_check(form, 'foo=on&baz=on');
137 |     empty_check(form, 'foo=on&bar=&baz=on');
138 |     empty_check_hash(form, {
139 |         'foo': 'on',
140 |         'bar': '',
141 |         'baz': 'on'
142 |     });
143 | });
144 | 
145 | test('checkboxes - array', function() {
146 |     var form = domify('<form>' +
147 |         '<input type="checkbox" name="foo[]" value="bar" checked/>' +
148 |         '<input type="checkbox" name="foo[]" value="baz" checked/>' +
149 |         '<input type="checkbox" name="foo[]" value="baz"/>' +
150 |         '</form>');
151 |     hash_check(form, {
152 |         'foo': ['bar', 'baz']
153 |     });
154 |     str_check(form, 'foo%5B%5D=bar&foo%5B%5D=baz');
155 |     empty_check(form, 'foo%5B%5D=bar&foo%5B%5D=baz&foo%5B%5D=');
156 |     empty_check_hash(form, {
157 |         'foo': ['bar', 'baz', '']
158 |     });
159 | });
160 | 
161 | test('checkboxes - array with single item', function() {
162 |     var form = domify('<form>' +
163 |         '<input type="checkbox" name="foo[]" value="bar" checked/>' +
164 |         '</form>');
165 |     hash_check(form, {
166 |         'foo': ['bar']
167 |     });
168 |     str_check(form, 'foo%5B%5D=bar');
169 | });
170 | 
171 | test('select - single', function() {
172 |     var form = domify('<form>' +
173 |         '<select name="foo">' +
174 |         '<option value="bar">bar</option>' +
175 |         '<option value="baz" selected>baz</option>' +
176 |         '</select>' +
177 |         '</form>');
178 |     hash_check(form, {
179 |         'foo': 'baz'
180 |     });
181 |     str_check(form, 'foo=baz');
182 | });
183 | 
184 | test('select - single - empty', function () {
185 |     var form = domify('<form>' +
186 |         '<select name="foo">' +
187 |         '<option value="">empty</option>' +
188 |         '<option value="bar">bar</option>' +
189 |         '<option value="baz">baz</option>' +
190 |         '</select>' +
191 |         '</form>');
192 |     hash_check(form, {});
193 |     str_check(form, '');
194 |     empty_check(form, 'foo=');
195 |     empty_check_hash(form, {
196 |         'foo': ''
197 |     });
198 | });
199 | 
200 | test('select - multiple', function() {
201 |     var form = domify('<form>' +
202 |         '<select name="foo" multiple>' +
203 |         '<option value="bar" selected>bar</option>' +
204 |         '<option value="baz">baz</option>' +
205 |         '<option value="cat" selected>cat</option>' +
206 |         '</select>' +
207 |         '</form>');
208 |     hash_check(form, {
209 |         'foo': ['bar', 'cat']
210 |     });
211 |     str_check(form, 'foo=bar&foo=cat');
212 | });
213 | 
214 | test('select - multiple - empty', function() {
215 |     var form = domify('<form>' +
216 |         '<select name="foo" multiple>' +
217 |         '<option value="">empty</option>' +
218 |         '<option value="bar">bar</option>' +
219 |         '<option value="baz">baz</option>' +
220 |         '<option value="cat">cat</option>' +
221 |         '</select>' +
222 |         '</form>');
223 |     hash_check(form, {});
224 |     str_check(form, '');
225 |     empty_check(form, 'foo=');
226 |     empty_check_hash(form, {
227 |         'foo': ''
228 |     });
229 | });
230 | 
231 | test('radio - no default', function() {
232 |     var form = domify('<form>' +
233 |         '<input type="radio" name="foo" value="bar1"/>' +
234 |         '<input type="radio" name="foo" value="bar2"/>' +
235 |         '</form>');
236 |     hash_check(form, {});
237 |     str_check(form, '');
238 |     empty_check(form, 'foo=');
239 |     empty_check_hash(form, {
240 |         'foo':''
241 |     });
242 | });
243 | 
244 | test('radio - single default', function() {
245 |     var form = domify('<form>' +
246 |         '<input type="radio" name="foo" value="bar1" checked="checked"/>' +
247 |         '<input type="radio" name="foo" value="bar2"/>' +
248 |         '</form>');
249 |     hash_check(form, {
250 |         foo: 'bar1'
251 |     });
252 |     str_check(form, 'foo=bar1');
253 |     empty_check(form, 'foo=bar1');
254 |     empty_check_hash(form, {
255 |         foo: 'bar1'
256 |     });
257 | });
258 | 
259 | test('radio - empty value', function() {
260 |     var form = domify('<form>' +
261 |         '<input type="radio" name="foo" value="" checked="checked"/>' +
262 |         '<input type="radio" name="foo" value="bar2"/>' +
263 |         '</form>');
264 |     hash_check(form, {});
265 |     str_check(form, '');
266 |     empty_check(form, 'foo=');
267 |     empty_check_hash(form, {
268 |         'foo':''
269 |     });
270 | });
271 | 
272 | // in this case the radio buttons and checkboxes share a name key
273 | // the checkbox value should still be honored
274 | test('radio w/checkbox', function() {
275 |     var form = domify('<form>' +
276 |         '<input type="radio" name="foo" value="bar1" checked="checked"/>' +
277 |         '<input type="radio" name="foo" value="bar2"/>' +
278 |         '<input type="checkbox" name="foo" value="bar3" checked="checked"/>' +
279 |         '<input type="checkbox" name="foo" value="bar4"/>' +
280 |         '</form>');
281 |     hash_check(form, {
282 |         foo: ['bar1', 'bar3']
283 |     });
284 |     str_check(form, 'foo=bar1&foo=bar3');
285 | 
286 |     // leading checkbox
287 |     form = domify('<form>' +
288 |         '<input type="checkbox" name="foo" value="bar3" checked="checked"/>' +
289 |         '<input type="radio" name="foo" value="bar1" checked="checked"/>' +
290 |         '<input type="radio" name="foo" value="bar2"/>' +
291 |         '<input type="checkbox" name="foo" value="bar4"/>' +
292 |         '<input type="checkbox" name="foo" value="bar5" checked="checked"/>' +
293 |         '</form>');
294 |     hash_check(form, {
295 |         foo: ['bar3', 'bar1', 'bar5']
296 |     });
297 |     str_check(form, 'foo=bar3&foo=bar1&foo=bar5');
298 | });
299 | 
300 | test('bracket notation - hashes', function() {
301 |     var form = domify('<form>' +
302 |         '<input type="email" name="account[name]" value="Foo Dude">' +
303 |         '<input type="text" name="account[email]" value="foobar@example.org">' +
304 |         '<input type="text" name="account[address][city]" value="Qux">' +
305 |         '<input type="text" name="account[address][state]" value="CA">' +
306 |         '<input type="text" name="account[address][empty]" value="">' +
307 |         '</form>');
308 | 
309 |     hash_check(form, {
310 |         account: {
311 |             name: 'Foo Dude',
312 |             email: 'foobar@example.org',
313 |             address: {
314 |                 city: 'Qux',
315 |                 state: 'CA'
316 |             }
317 |         }
318 |     });
319 | 
320 |     empty_check_hash(form, {
321 |         account: {
322 |             name: 'Foo Dude',
323 |             email: 'foobar@example.org',
324 |             address: {
325 |                 city: 'Qux',
326 |                 state: 'CA',
327 |                 empty: ''
328 |             }
329 |         }
330 |     });
331 | });
332 | 
333 | test('bracket notation - hashes with a digit as the first symbol in a key', function() {
334 |     var form = domify('<form>' +
335 |         '<input type="text" name="somekey[123abc][first]" value="first_value">' +
336 |         '<input type="text" name="somekey[123abc][second]" value="second_value">' +
337 |         '</form>');
338 | 
339 |     hash_check(form, {
340 |         'somekey': {
341 |             '123abc': {
342 |                 'first': 'first_value',
343 |                 'second': 'second_value'
344 |             }
345 |         }
346 |     });
347 | 
348 |     empty_check_hash(form, {
349 |         'somekey': {
350 |             '123abc': {
351 |                 'first': 'first_value',
352 |                 'second': 'second_value'
353 |             }
354 |         }
355 |     });
356 | });
357 | 
358 | test('bracket notation - select multiple', function() {
359 |     var form = domify('<form>' +
360 |         '<select name="foo" multiple>' +
361 |         '  <option value="bar" selected>Bar</option>' +
362 |         '  <option value="baz">Baz</option>' +
363 |         '  <option value="qux" selected>Qux</option>' +
364 |         '</select>' +
365 |         '</form>');
366 | 
367 |     hash_check(form, {
368 |         foo: [ 'bar', 'qux' ]
369 |     });
370 | 
371 |     // Trailing notation on select.name.
372 |     form = domify('<form>' +
373 |         '<select name="foo[]" multiple>' +
374 |         '  <option value="bar" selected>Bar</option>' +
375 |         '  <option value="baz">Baz</option>' +
376 |         '  <option value="qux" selected>Qux</option>' +
377 |         '</select>' +
378 |         '</form>');
379 | 
380 |     hash_check(form, {
381 |         foo: [ 'bar', 'qux' ]
382 |     });
383 | });
384 | 
385 | 
386 | test('bracket notation - select multiple, nested', function() {
387 |     var form = domify('<form>' +
388 |         '<select name="foo[bar]" multiple>' +
389 |         '  <option value="baz" selected>Baz</option>' +
390 |         '  <option value="qux">Qux</option>' +
391 |         '  <option value="norf" selected>Norf</option>' +
392 |         '</select>' +
393 |         '</form>');
394 | 
395 |     hash_check(form, {
396 |         foo: {
397 |             bar: [ 'baz', 'norf' ]
398 |         }
399 |     });
400 | });
401 | 
402 | test('bracket notation - select multiple, empty values', function() {
403 |     var form = domify('<form>' +
404 |         '<select name="foo[bar]" multiple>' +
405 |         '  <option selected>Default value</option>' +
406 |         '  <option value="" selected>Empty value</option>' +
407 |         '  <option value="baz" selected>Baz</option>' +
408 |         '  <option value="qux">Qux</option>' +
409 |         '  <option value="norf" selected>Norf</option>' +
410 |         '</select>' +
411 |         '</form>');
412 | 
413 |     hash_check(form, {
414 |         foo: {
415 |             bar: [ 'Default value', 'baz', 'norf' ]
416 |         }
417 |     });
418 | 
419 |     empty_check_hash(form, {
420 |         foo: {
421 |             bar: [ 'Default value', '', 'baz', 'norf' ]
422 |         }
423 |     });
424 | });
425 | 
426 | test('bracket notation - non-indexed arrays', function() {
427 |     var form = domify('<form>' +
428 |         '<input name="people[][name]" value="fred" />' +
429 |         '<input name="people[][name]" value="bob" />' +
430 |         '<input name="people[][name]" value="bubba" />' +
431 |         '</form>');
432 | 
433 |     hash_check(form, {
434 |         people: [
435 |             { name: "fred" },
436 |             { name: "bob" },
437 |             { name: "bubba" },
438 |         ]
439 |     });
440 | });
441 | 
442 | test('bracket notation - nested, non-indexed arrays', function() {
443 |     var form = domify('<form>' +
444 |         '<input name="user[tags][]" value="cow" />' +
445 |         '<input name="user[tags][]" value="milk" />' +
446 |         '</form>');
447 | 
448 |     hash_check(form, {
449 |         user: {
450 |             tags: [ "cow", "milk" ],
451 |         }
452 |     });
453 | });
454 | 
455 | test('bracket notation - indexed arrays', function() {
456 |     var form = domify('<form>' +
457 |         '<input name="people[2][name]" value="bubba" />' +
458 |         '<input name="people[2][age]" value="15" />' +
459 |         '<input name="people[0][name]" value="fred" />' +
460 |         '<input name="people[0][age]" value="12" />' +
461 |         '<input name="people[1][name]" value="bob" />' +
462 |         '<input name="people[1][age]" value="14" />' +
463 |         '<input name="people[][name]" value="frank">' +
464 |         '<input name="people[3][age]" value="2">' +
465 |         '</form>');
466 | 
467 |     hash_check(form, {
468 |         people: [
469 |             {
470 |                 name: "fred",
471 |                 age: "12"
472 |             },
473 |             {
474 |                 name: "bob",
475 |                 age: "14"
476 |             },
477 |             {
478 |                 name: "bubba",
479 |                 age: "15"
480 |             },
481 |             {
482 |                 name: "frank",
483 |                 age: "2"
484 |             }
485 |         ]
486 |     });
487 | });
488 | 
489 | test('bracket notation - bad notation', function() {
490 |     var form = domify('<form>' +
491 |         '<input name="[][foo]" value="bar" />' +
492 |         '<input name="[baz][qux]" value="norf" />' +
493 |         '</form>');
494 | 
495 |     hash_check(form, {
496 |         _values: [
497 |             { foo: 'bar' }
498 |         ],
499 |         baz: { qux: 'norf' }
500 |     });
501 | });
502 | 
503 | test('custom serializer', function() {
504 |   var form = domify('<form><input type="text" name="node" value="zuul">/</form>');
505 | 
506 |   assert.deepEqual(serialize(form, {
507 |     serializer: function(curry, k, v) {
508 |       curry[k] = 'ZUUL';
509 |       return curry;
510 |     }
511 |   }), {
512 |     "node": "ZUUL"
513 |   });
514 | });
515 | 


--------------------------------------------------------------------------------