| 1 | 1 | (function() { |
| 2 | 1 | var NamedParameters, exports; |
| 3 | | |
| 4 | 1 | NamedParameters = (function() { |
| 5 | 1 | var _assert, _clone; |
| 6 | | |
| 7 | 1 | function NamedParameters(m) { |
| 8 | 120 | this.map = _clone(m); |
| 9 | 120 | this.coerce_all = false; |
| 10 | | } |
| 11 | | |
| 12 | 1 | NamedParameters.prototype.values = function() { |
| 13 | 53 | return this.map; |
| 14 | | }; |
| 15 | | |
| 16 | 1 | NamedParameters.prototype["default"] = function(name, value) { |
| 17 | 18 | if (typeof name === 'object' && !(value != null)) { |
| 18 | 1 | this.defaults(name); |
| 19 | | } else { |
| 20 | 29 | if (this.map[name] == null) this.map[name] = value; |
| 21 | | } |
| 22 | 18 | return this; |
| 23 | | }; |
| 24 | | |
| 25 | 1 | NamedParameters.prototype.defaults = function(map) { |
| 26 | 3 | var n, v; |
| 27 | 3 | for (n in map) { |
| 28 | 10 | v = map[n]; |
| 29 | 10 | this["default"](n, v); |
| 30 | | } |
| 31 | 3 | return this; |
| 32 | | }; |
| 33 | | |
| 34 | 1 | NamedParameters.prototype.coerce = function(name, type, whennull) { |
| 35 | 10 | var n, v, value; |
| 36 | 20 | if (whennull == null) whennull = null; |
| 37 | 10 | if (typeof name === 'boolean') { |
| 38 | 3 | this.coerce_all = name; |
| 39 | 7 | } else if (typeof name === 'object') { |
| 40 | 0 | for (n in name) { |
| 41 | 0 | v = name[n]; |
| 42 | 0 | this.coerce(n, v); |
| 43 | | } |
| 44 | | } else { |
| 45 | 7 | value = this.map[name]; |
| 46 | 7 | switch (type) { |
| 47 | | case 'integer': |
| 48 | 2 | if (value != null) { |
| 49 | 2 | this.map[name] = Math.floor(Number(value)); |
| 50 | | } else { |
| 51 | 0 | this.map[name] = Math.floor(Number(whennull)); |
| 52 | | } |
| 53 | 2 | break; |
| 54 | | case 'number': |
| 55 | 5 | if (value != null) { |
| 56 | 5 | this.map[name] = Number(value); |
| 57 | | } else { |
| 58 | 0 | this.map[name] = Number(whennull); |
| 59 | | } |
| 60 | 5 | break; |
| 61 | | case 'string': |
| 62 | 0 | if (value != null) { |
| 63 | 0 | this.map[name] = String(value); |
| 64 | | } else { |
| 65 | 0 | this.map[name] = String(whennull); |
| 66 | | } |
| 67 | 0 | break; |
| 68 | | case 'boolean': |
| 69 | 0 | if (typeof value === 'string') { |
| 70 | 0 | v = value.toLowerCase(); |
| 71 | 0 | this.map[name] = v === 'true' || v === 't' || v === 'yes' || v === 'y' || v === '1' || v === 'on'; |
| 72 | 0 | } else if (typeof value === 'function') { |
| 73 | 0 | this.map[name] = value(); |
| 74 | | } else { |
| 75 | 0 | this.map[name] = value ? true : false; |
| 76 | | } |
| 77 | 0 | break; |
| 78 | | case 'array': |
| 79 | 0 | if (value != null) { |
| 80 | 0 | if (!(value instanceof Array)) this.map[name] = [value]; |
| 81 | 0 | } else if (whennull != null) { |
| 82 | 0 | if (!(whennull instanceof Array)) this.map[name] = [whennull]; |
| 83 | | } |
| 84 | 0 | break; |
| 85 | | default: |
| 86 | 0 | throw "I don't know how to coerce parameter \"" + name + "\" into the unrecognized type \"" + type + "\"."; |
| 87 | | } |
| 88 | | } |
| 89 | 10 | return this; |
| 90 | | }; |
| 91 | | |
| 92 | 1 | NamedParameters.prototype.require = function(name, validation, message) { |
| 93 | 104 | var value; |
| 94 | 110 | if (validation == null) validation = null; |
| 95 | 208 | if (message == null) message = null; |
| 96 | 104 | switch (typeof validation) { |
| 97 | | case 'string': |
| 98 | 98 | switch (validation.toLowerCase()) { |
| 99 | | case 'non empty string': |
| 100 | | case 'non-empty string': |
| 101 | | case 'non blank string': |
| 102 | | case 'non-blank string': |
| 103 | 12 | if (this.coerce_all) this.coerce(name, 'string'); |
| 104 | 12 | value = this.map[name]; |
| 105 | 12 | if (message == null) { |
| 106 | 12 | message = "Expected " + name + " parameter to be a non-empty String. Found \"" + value + "\"."; |
| 107 | | } |
| 108 | 12 | _assert((value != null) && (typeof value === 'string') && value.length > 0, message); |
| 109 | 2 | break; |
| 110 | | case 'non empty array': |
| 111 | | case 'non-empty array': |
| 112 | 0 | if (this.coerce_all) this.coerce(name, 'array'); |
| 113 | 0 | value = this.map[name]; |
| 114 | 0 | if (message == null) { |
| 115 | 0 | message = "Expected " + name + " parameter to be a non-empty Array. Found \"" + value + "\"."; |
| 116 | | } |
| 117 | 0 | _assert((value != null) && (value instanceof Array) && value.length > 0, message); |
| 118 | 0 | break; |
| 119 | | case 'number': |
| 120 | | case 'numeric': |
| 121 | 8 | if (this.coerce_all) this.coerce(name, 'number'); |
| 122 | 7 | value = this.map[name]; |
| 123 | 7 | if (message == null) { |
| 124 | 7 | message = "Expected " + name + " parameter to be a numeric value. Found \"" + value + "\"."; |
| 125 | | } |
| 126 | 7 | _assert((value != null) && (typeof value === 'number'), message); |
| 127 | 4 | break; |
| 128 | | case 'positive number': |
| 129 | | case 'positive': |
| 130 | 8 | if (this.coerce_all) this.coerce(name, 'number'); |
| 131 | 8 | value = this.map[name]; |
| 132 | 8 | if (message == null) { |
| 133 | 8 | message = "Expected " + name + " parameter to be a positive number. Found \"" + value + "\"."; |
| 134 | | } |
| 135 | 8 | _assert((value != null) && (typeof value === 'number') && value > 0, message); |
| 136 | 2 | break; |
| 137 | | case 'negative number': |
| 138 | | case 'negative': |
| 139 | 8 | if (this.coerce_all) this.coerce(name, 'number'); |
| 140 | 8 | value = this.map[name]; |
| 141 | 8 | if (message == null) { |
| 142 | 8 | message = "Expected " + name + " parameter to be a negative number. Found \"" + value + "\"."; |
| 143 | | } |
| 144 | 8 | _assert((value != null) && (typeof value === 'number') && value < 0, message); |
| 145 | 2 | break; |
| 146 | | case 'non-negative number': |
| 147 | | case 'non negative number': |
| 148 | | case 'non negative': |
| 149 | | case 'non-negative': |
| 150 | 8 | if (this.coerce_all) this.coerce(name, 'number'); |
| 151 | 8 | value = this.map[name]; |
| 152 | 8 | if (message == null) { |
| 153 | 8 | message = "Expected " + name + " parameter to be a non-negative number. Found \"" + value + "\"."; |
| 154 | | } |
| 155 | 8 | _assert((value != null) && (typeof value === 'number') && value >= 0, message); |
| 156 | 4 | break; |
| 157 | | case 'non-positive number': |
| 158 | | case 'non positive number': |
| 159 | | case 'non-positive': |
| 160 | | case 'non positive': |
| 161 | 8 | if (this.coerce_all) this.coerce(name, 'number'); |
| 162 | 8 | value = this.map[name]; |
| 163 | 8 | if (message == null) { |
| 164 | 8 | message = "Expected " + name + " parameter to be a non-positive number. Found \"" + value + "\"."; |
| 165 | | } |
| 166 | 8 | _assert((value != null) && (typeof value === 'number') && value <= 0, message); |
| 167 | 4 | break; |
| 168 | | case 'non-zero number': |
| 169 | | case 'non zero number': |
| 170 | | case 'non-zero': |
| 171 | | case 'non zero': |
| 172 | 8 | if (this.coerce_all) this.coerce(name, 'number'); |
| 173 | 8 | value = this.map[name]; |
| 174 | 8 | if (message == null) { |
| 175 | 8 | message = "Expected " + name + " parameter to be a non-zero number. Found \"" + value + "\"."; |
| 176 | | } |
| 177 | 8 | _assert((value != null) && (typeof value === 'number') && value !== 0, message); |
| 178 | 4 | break; |
| 179 | | case 'integer': |
| 180 | 10 | if (this.coerce_all) this.coerce(name, 'integer'); |
| 181 | 8 | value = this.map[name]; |
| 182 | 8 | if (message == null) { |
| 183 | 8 | message = "Expected " + name + " parameter to be an integer. Found \"" + value + "\"."; |
| 184 | | } |
| 185 | 8 | _assert((value != null) && (typeof value === 'number') && Math.floor(value) === value, message); |
| 186 | 4 | break; |
| 187 | | case 'positive integer': |
| 188 | 5 | if (this.coerce_all) this.coerce(name, 'integer'); |
| 189 | 5 | value = this.map[name]; |
| 190 | 5 | if (message == null) { |
| 191 | 5 | message = "Expected " + name + " parameter to be a positive integer. Found \"" + value + "\"."; |
| 192 | | } |
| 193 | 5 | _assert((value != null) && (typeof value === 'number') && Math.floor(value) === value && value > 0, message); |
| 194 | 1 | break; |
| 195 | | case 'negative integer': |
| 196 | 5 | if (this.coerce_all) this.coerce(name, 'integer'); |
| 197 | 5 | value = this.map[name]; |
| 198 | 5 | if (message == null) { |
| 199 | 5 | message = "Expected " + name + " parameter to be a negative integer. Found \"" + value + "\"."; |
| 200 | | } |
| 201 | 5 | _assert((value != null) && (typeof value === 'number') && Math.floor(value) === value && value < 0, message); |
| 202 | 1 | break; |
| 203 | | case 'non-negative integer': |
| 204 | 5 | if (this.coerce_all) this.coerce(name, 'integer'); |
| 205 | 5 | value = this.map[name]; |
| 206 | 5 | if (message == null) { |
| 207 | 5 | message = "Expected " + name + " parameter to be a non-negative integer. Found \"" + value + "\"."; |
| 208 | | } |
| 209 | 5 | _assert((value != null) && (typeof value === 'number') && Math.floor(value) === value && value >= 0, message); |
| 210 | 2 | break; |
| 211 | | case 'non-positive integer': |
| 212 | 5 | if (this.coerce_all) this.coerce(name, 'integer'); |
| 213 | 5 | value = this.map[name]; |
| 214 | 5 | if (message == null) { |
| 215 | 5 | message = "Expected " + name + " parameter to be a non-positive integer. Found \"" + value + "\"."; |
| 216 | | } |
| 217 | 5 | _assert((value != null) && (typeof value === 'number') && Math.floor(value) === value && value <= 0, message); |
| 218 | 2 | break; |
| 219 | | case 'non-zero integer': |
| 220 | 5 | if (this.coerce_all) this.coerce(name, 'integer'); |
| 221 | 5 | value = this.map[name]; |
| 222 | 5 | if (message == null) { |
| 223 | 5 | message = "Expected " + name + " parameter to be a non-zero integer. Found \"" + value + "\"."; |
| 224 | | } |
| 225 | 5 | _assert((value != null) && (typeof value === 'number') && Math.floor(value) === value && value !== 0, message); |
| 226 | 2 | break; |
| 227 | | case 'string': |
| 228 | 5 | if (this.coerce_all) this.coerce(name, 'string'); |
| 229 | 5 | value = this.map[name]; |
| 230 | 5 | if (message == null) { |
| 231 | 5 | message = "Expected " + name + " parameter to be a non-null string. Found \"" + value + "\"."; |
| 232 | | } |
| 233 | 5 | _assert((value != null) && (typeof value === 'string'), message); |
| 234 | 1 | break; |
| 235 | | case 'object': |
| 236 | 0 | value = this.map[name]; |
| 237 | 0 | if (message == null) { |
| 238 | 0 | message = "Expected " + name + " parameter to be a non-null Object. Found \"" + value + "\"."; |
| 239 | | } |
| 240 | 0 | _assert((value != null) && (typeof value === 'object'), message); |
| 241 | 0 | break; |
| 242 | | case 'array': |
| 243 | 0 | if (this.coerce_all) this.coerce(name, 'array'); |
| 244 | 0 | value = this.map[name]; |
| 245 | 0 | if (message == null) { |
| 246 | 0 | message = "Expected " + name + " parameter to be a non-null Array. Found \"" + value + "\"."; |
| 247 | | } |
| 248 | 0 | _assert((value != null) && (value instanceof Array), message); |
| 249 | 0 | break; |
| 250 | | case 'boolean': |
| 251 | 0 | if (this.coerce_all) this.coerce(name, 'boolean'); |
| 252 | 0 | value = this.map[name]; |
| 253 | 0 | if (message == null) { |
| 254 | 0 | message = "Expected " + name + " parameter to be a non-null boolean. Found \"" + value + "\"."; |
| 255 | | } |
| 256 | 0 | _assert((value != null) && (typeof value === 'boolean'), message); |
| 257 | 0 | break; |
| 258 | | case 'not null': |
| 259 | 1 | value = this.map[name]; |
| 260 | 1 | if (message == null) { |
| 261 | 1 | message = "Expected " + name + " parameter to be non-null value. Found (\"" + value + "\")."; |
| 262 | | } |
| 263 | 1 | _assert(value != null, message); |
| 264 | 0 | break; |
| 265 | | default: |
| 266 | 0 | throw "Unrecognized validator string \"" + validation + "\"."; |
| 267 | | } |
| 268 | 35 | break; |
| 269 | | case 'function': |
| 270 | 0 | value = this.map[name]; |
| 271 | 0 | if (message == null) { |
| 272 | 0 | message = "Expected " + name + " parameter (\"" + value + "\") to pass validation " + validation + "."; |
| 273 | | } |
| 274 | 0 | _assert(validation(name), message); |
| 275 | 0 | break; |
| 276 | | case 'object': |
| 277 | 6 | if (validation != null) { |
| 278 | 0 | throw "Unrecognized validator object \"" + validation + "\"."; |
| 279 | | } else { |
| 280 | 6 | value = this.map[name]; |
| 281 | 6 | if (message == null) { |
| 282 | 6 | message = "Expected " + name + " parameter to be non-null value. Found (\"" + value + "\")."; |
| 283 | | } |
| 284 | 6 | _assert(value != null, message); |
| 285 | | } |
| 286 | 2 | break; |
| 287 | | default: |
| 288 | 0 | throw "Unrecognized validator string \"" + validation + "\"."; |
| 289 | | } |
| 290 | 37 | return this; |
| 291 | | }; |
| 292 | | |
| 293 | 1 | NamedParameters.prototype.demand = function(name, validation, message) { |
| 294 | 3 | return this.require(name, validation, message); |
| 295 | | }; |
| 296 | | |
| 297 | 1 | _clone = function(obj) { |
| 298 | 120 | var clone, n, v; |
| 299 | 120 | clone = {}; |
| 300 | 120 | for (n in obj) { |
| 301 | 138 | v = obj[n]; |
| 302 | 276 | if (obj.hasOwnProperty(n)) clone[n] = v; |
| 303 | | } |
| 304 | 120 | return clone; |
| 305 | | }; |
| 306 | | |
| 307 | 1 | _assert = function(bool, message) { |
| 308 | 104 | if (message == null) message = "Invalid parameter"; |
| 309 | 171 | if (!bool) throw message; |
| 310 | | }; |
| 311 | | |
| 312 | 1 | return NamedParameters; |
| 313 | | |
| 314 | | })(); |
| 315 | | |
| 316 | 1 | exports = exports != null ? exports : this; |
| 317 | | |
| 318 | 1 | exports.parse = function(map) { |
| 319 | 119 | return new NamedParameters(map); |
| 320 | | }; |
| 321 | | |
| 322 | 1 | exports.NamedParameters = NamedParameters; |
| 323 | | |
| 324 | | }).call(this); |