├── lemongrab.png
├── README.md
├── composer.json
└── jquery.lemongrab.js


/lemongrab.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pozitronik/jquery.lemongrab/HEAD/lemongrab.png


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | jquery.lemongrab
2 | ================
3 | 
4 | jquery.lemongrab.js - простой и минималистичный jQuery-плагин для валидации форм. С его помощью можно задавать условия валидации полей, описывать реакцию на изменение состояния, и связывать поля по условиям.
5 | 
6 | Документация и примеры доступны здесь: http://pozitronik.me/lemongrab
7 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 		"name": "pozitronik/jquery.lemongrab",
 3 | 		"description": "jQuery web-form validation plugin",
 4 | 		"type": "library",
 5 | 		"license": [
 6 | 				"GPL-3.0",
 7 | 		],
 8 | 		"homepage": "http://pozitronik.me/lemongrab",
 9 | 		"authors": [
10 | 				{
11 | 						"name": "Pavel Dubrovsky",
12 | 						"homepage": "http://pozitronik.me",
13 | 						"role": "Developer"
14 | 				},
15 | 		]
16 | }
17 | 


--------------------------------------------------------------------------------
/jquery.lemongrab.js:
--------------------------------------------------------------------------------
  1 | /*! Lemongrab v 11.03.15 | (c) 2013-2015 Pavel Dubrovsky*/
  2 | 
  3 | (function( $ ) {
  4 | 	var
  5 | 	ValidState=false,
  6 | 	RequiredState=false,
  7 | 	VisibleState=false,
  8 | 	FORM,//Глобальный (для плагина) объект формы, на которую он натравлен
  9 | 	ACCEPTABLE;
 10 | 
 11 | 
 12 | 	jQuery.fn.lemongrab = function(options,RULES) {
 13 | 		ACCEPTABLE=$.extend({	"subselector":"*",
 14 | 													"classValid":"ACCEPTABLE",
 15 | 													"classInvalid":"UNACCEPTABLE",
 16 | 													"classRequired":"REQUIRED",
 17 | 													"classNorequired":"NOREQUIRED",
 18 | 													"classEnabled":"ENABLED",
 19 | 													"classDisabled":"DISABLED",
 20 | 													"classVisible":"VISIBLE",
 21 | 													"classHidden":"HIDDEN",
 22 | 													"classChanged":"CHANGED",
 23 | 													"classUnchanged":"UNCHANGED",
 24 | 													"action":"input",
 25 | 													"actions":{},
 26 | 													"onAction":false,
 27 | 													"allowInvalidSubmit":true,
 28 | 													"useRequiredAttr":true,
 29 | 													"nativeEnabled":true,
 30 | 													"nativeVisible":true,
 31 | 													"autograb":true,
 32 | 													"ignore_autograb_change":true,//Игнорировать смену состояний Changed/Unchanged при autograb=true
 33 | 													"ignore_autograb_action":false//Игнорировать вызов события onAction при autograb=true
 34 | 												},options);
 35 | 		FORM=this;
 36 | 		
 37 | 		var rule,conditions,selector_count,conditions_count,rule_options={},lemons,lemon,rules;
 38 | 		
 39 | 		//если в RULES что-то задано - считаем, что там JSON, парсим его.
 40 | 		if (typeof(RULES)!=='undefined' && RULES!=='') {
 41 | 			var for_selector;
 42 | 			for (selector_count=0;selector_count<RULES.length;selector_count++){//Разбиваем переданный параметр на селекторы
 43 | 				for_selector=RULES[selector_count].selector;
 44 | 				//Перебираем все условия валидации
 45 | 				for (e_rule in RULES[selector_count].rule) {
 46 | 					rule=e_rule.toUpperCase();
 47 | 					conditions=RULES[selector_count].rule[e_rule];
 48 | 					//В conditions-набор условий правила. В rule-само правило.
 49 | 					rule_options={};
 50 | 					for (conditions_count=0;conditions_count<conditions.length;conditions_count++){//Пройдёмся по условиям, дополнив умолчания. Можно использовать существующий объект
 51 | 						rule_options[conditions_count]=complete_condition(conditions[conditions_count]);
 52 | 					}
 53 | 					rule_options.actions=RULES[selector_count].actions;
 54 | 					apply_rule($(for_selector),rule,rule_options);
 55 | 				}
 56 | 			}
 57 | 		}
 58 | 		
 59 | 		lemons=FORM.find(ACCEPTABLE.subselector);
 60 | 		lemons.each(function(){
 61 | 			lemon=$(this);
 62 | 			rules=lemon.data();//Получили список data-атрибутов
 63 | 			for (var rule_ in rules) {
 64 | 				if (['ruleValid','ruleRequired','ruleEnabled','ruleVisible','ruleLemongrab'].indexOf(rule_)===-1) continue;
 65 | 				conditions=rules[rule_];
 66 | 				switch (rule_){
 67 | 					case 'ruleValid':
 68 | 						rule="VALID";
 69 | 					break;
 70 | 					case 'ruleRequired':
 71 | 						rule="REQUIRED";
 72 | 					break;
 73 | 					case 'ruleEnabled':
 74 | 						rule="ENABLED";
 75 | 					break;
 76 | 					case 'ruleVisible':
 77 | 						rule="VISIBLE";
 78 | 					break;
 79 | 					case 'ruleLemongrab': //Отдельный случай: одно большое правило
 80 | 						var parameters=conditions,
 81 | 								parameter;
 82 | 						for (parameter in parameters) {
 83 | 							conditions=parameters[parameter];
 84 | 							switch (parameter){
 85 | 								case 'valid':
 86 | 									rule="VALID";
 87 | 								break;
 88 | 								case 'required':
 89 | 									rule="REQUIRED";
 90 | 								break;
 91 | 								case 'enabled':
 92 | 									rule="ENABLED";
 93 | 								break;
 94 | 								case 'visible':
 95 | 									rule="VISIBLE";
 96 | 								break;
 97 | 							}
 98 | 							//В conditions-набор условий правила. В rule-само правило.
 99 | 							rule_options={};
100 | 							for (conditions_count=0;conditions_count<conditions.length;conditions_count++){//Пройдёмся по условиям, дополнив умолчания. Можно использовать существующий объект
101 | 								rule_options[conditions_count]=complete_condition(conditions[conditions_count]);
102 | 							}
103 | 							apply_rule(lemon,rule,rule_options);
104 | 						}
105 | 					break;
106 | 				}
107 | 				//В conditions-набор условий правила. В rule-само правило.
108 | 				rule_options={};
109 | 				for (conditions_count=0;conditions_count<conditions.length;conditions_count++){//Пройдёмся по условиям, дополнив умолчания. Можно использовать существующий объект
110 | 					rule_options[conditions_count]=complete_condition(conditions[conditions_count]);
111 | 				}
112 | 				//rule_options.actions=RULES[selector_count].actions;
113 | 				apply_rule(lemon,rule,rule_options);
114 | 			}
115 | 		});
116 | 		ValidState=FORM.isValid();
117 | 		RequiredState=!FORM.isNotRequired();
118 | 		VisibleState=FORM.is(':visible');
119 | 		//Устанавливаем обработчик onsubmit
120 | 		FORM.on('submit',function(){
121 | 			if (!FORM.isNotRequired()) return (false);
122 | 			if (FORM.isValid()) return (true);
123 | 			return (ACCEPTABLE.allowInvalidSubmit===true);
124 | 		});
125 | 	};
126 | 
127 | 	jQuery.fn.isValid = function(){
128 | 		return (this.find("."+ACCEPTABLE.classInvalid).length===0);
129 | 	};
130 | 	
131 | 	jQuery.fn.isNotRequired = function(){
132 | 		return (this.find("."+ACCEPTABLE.classRequired).length===0);
133 | 	};
134 | 	
135 | 	function complete_condition(condition){//Проверяет условие на все параметры, дополняет умолчательными. TODO: разрешить использовать сокращённую запись (& вместо and и тд).
136 | 		condition.key=(condition.key||'native');//Получаем ключ правила, если не задан - считаем, что там нативный JS.
137 | 		
138 | 		condition.invert=(condition.invert||false);//Инвертировать ли полученное значение.
139 | 		if (condition.key[0]==='!') {//Инвертирование может быть задано в ключе. В случае, если оно задано и в ключе, и в параметре, ключ имеет приоритет
140 | 			condition.invert=true;
141 | 			condition.key=condition.key.substr(1);
142 | 		}
143 | 		
144 | 		switch (condition.key.toLowerCase()){//Задаём алиасы ключей
145 | 			case 'r':
146 | 			case 'regexp':
147 | 				condition.key="regexp";
148 | 			break;
149 | 			case 'c':
150 | 			case 'checked':
151 | 			case 'checkbox':
152 | 			case 'radio':
153 | 				condition.key="checked";
154 | 			break;
155 | 			case 'select':
156 | 			case 's':
157 | 				condition.key="select";
158 | 			break;
159 | 			case 'set':
160 | 				condition.key="set";
161 | 			break;
162 | 			case 'j':
163 | 			case 'n':
164 | 			case 'f':
165 | 			case 'javascript':
166 | 			case 'native':
167 | 			case 'function':
168 | 				condition.key="native";
169 | 			break;
170 | 		}
171 | 		
172 | 		if (condition.key==="select"){//Нужно проверить, что в value
173 | 			var i,tmp_value="[";
174 | 			if (typeof(condition.value)==='object'){//Отлично, это массив
175 | 				for (i=0;i<condition.value.length;i++){
176 | 					tmp_value+="\""+condition.value[i]+"\",";
177 | 				}
178 | 			} else if (typeof(condition.value)==='string'){//Это не массив, но мы добры к пользователю
179 | 				condition.value=condition.value.split(',');
180 | 				for (i=0;i<condition.value.length;i++){
181 | 					tmp_value+="\""+condition.value[i]+"\",";
182 | 				}
183 | 			} else {
184 | 				tmp_value="[ ";
185 | 			}
186 | 			condition.value=tmp_value.substr(0,tmp_value.length-1)+"]";
187 | 		} else if (condition.key==="set") {
188 | 			condition.value=(condition.value||[""]);
189 | 		}
190 | 
191 | 		condition.selector=(condition.selector||'');//Селектор связуемого поля, если не задан - привязываемся к полю правила.
192 | 		condition.strict=(condition.strict||false);//Строгость проверки для select/set
193 | 		condition.logic=(condition.logic||'&&');//Логика совмещения правил
194 | 		condition.min=(condition.min||false);/*минимальное*/
195 | 		condition.max=(condition.max||false);/*и максимальное количество выбранных значений*/
196 | 		
197 | 		switch (condition.logic.toLowerCase()) {
198 | 			default:
199 | 			case "&":
200 | 			case "&&":
201 | 			case "and":
202 | 				condition.logic="&&";
203 | 			break;
204 | 			case "|":
205 | 			case "||":
206 | 			case "or":
207 | 				condition.logic="||";
208 | 			break;
209 | 		}
210 | 		return (condition);
211 | 	}
212 | 
213 | 	/*Возвращает в виде массива набор значений указанного <select>
214 | 		Входное значение - jQuery-объект с селектом
215 | 	*/
216 | 	function get_selected_options(select){
217 | 		var	options=select.find("option:selected"),
218 | 				option_count,
219 | 				ret=[];
220 | 		for (option_count=0;option_count<options.length;option_count++){
221 | 			ret.push($(options[option_count]).val());
222 | 		}
223 | 		return (ret);
224 | 	}
225 | 	
226 | 	/*
227 | 		проверяет, чекнуты ли в block поля, отмеченные в selectors.
228 | 		если strict==true, считается норм, если чекнуто хотя бы одно поле, попадающее под каждый селектор
229 | 		иначе должны быть чекнуты все поля, попадающие в селектор
230 | 	*/
231 | 	function is_fields_checked(block,selectors,strict){
232 | 		if (typeof(strict)==='undefined') strict=false;
233 | 		var index,selector,cl=0;
234 | 		for (index=0;index<selectors.length;index++){
235 | 			selector=selectors[index];
236 | 			cl+=block.find(selector+':checked').length;//Количество чекнутых для прошлого селектора не сбрасываем
237 | 			if (strict) {//TODO: условие можно и сократить для компактности
238 | 				if (cl!==block.find(selector).length) return (false);
239 | 			} else {
240 | 				if (cl>block.find(selector).length || cl===0) return (false);
241 | 			}
242 | 		}
243 | 		return (true);
244 | 	}
245 | 	
246 | 	/*
247 | 	 * По заданному набору параметров генерирует JS-код условия
248 | 	*/
249 | 	function get_js_condition (condition,field){
250 | 		var ret={
251 | 			handler:[],
252 | 			condition:""
253 | 		},_condition,summary_selector,index;
254 | 		
255 | 		switch (condition.key.toLowerCase()){
256 | 			case 'regexp':
257 | 				if (condition.selector!=='') {//Задан селектор внешнего поля, дополнительно вешаем обработчик на него
258 | 					ret.condition = "RegExp(/"+condition.value+"/).test($('"+condition.selector+"').val())";
259 | 					ret.handler.push("$('"+condition.selector+"')");
260 | 				} else {//Селектор не задан, проверяем собственное поле
261 | 					ret.condition = "RegExp(/"+condition.value+"/).test(field.val())";//field дальше будет обрабатываться eval
262 | 				}
263 | 			break;
264 | 			case 'checked':
265 | 				if (condition.selector!=='') {//Задан селектор внешнего поля, дополнительно вешаем обработчик на него
266 | 					ret.condition = "$('"+condition.selector+"').is(':checked')";
267 | 					ret.handler.push("$('"+condition.selector+"')");
268 | 				} else {//Селектор не задан, проверяем собственное поле
269 | 					ret.condition = "field.is(':checked')";
270 | 				}
271 | 			break;
272 | 			case 'select':
273 | 				_condition='';
274 | 				//В condition.value должен быть массив переведённый в строку - об этом заботимся в complete_condition
275 | 				if (condition.selector!=='') {//Задан селектор внешнего поля, дополнительно вешаем обработчик на него
276 | 					if (condition.min) {//Генерируем условие для min, если оно задано
277 | 						_condition+=" && (get_selected_options($('"+condition.selector+"')).length >= "+condition.min+")";
278 | 					}
279 | 					if (condition.max) {//Генерируем условие для max, если оно задано
280 | 						_condition+=" && (get_selected_options($('"+condition.selector+"')).length <= "+condition.max+")";
281 | 					}
282 | 					ret.condition = condition.value+".equals (get_selected_options($('"+condition.selector+"')),"+condition.strict+")"+_condition;
283 | 					ret.handler.push("$('"+condition.selector+"')");
284 | 				} else {//Селектор не задан, проверяем собственное поле
285 | 					
286 | 					if (condition.min) {//Генерируем условие для min, если оно задано
287 | 						_condition+=" && (get_selected_options(field).length >= "+condition.min+")";
288 | 					}
289 | 					if (condition.max) {//Генерируем условие для max, если оно задано
290 | 						_condition+=" && (get_selected_options(field).length <= "+condition.max+")";
291 | 					}
292 | 					ret.condition = condition.value+".equals (get_selected_options(field),"+condition.strict+")"+_condition;
293 | 				}
294 | 			break;
295 | 			case 'set':
296 | 				_condition='';
297 | 				summary_selector='';
298 | 				//Поскольку в condition.value должен быть массив селекторов, нужно разобрать его, сделав один большой селектор
299 | 				for (index=0;index<condition.value.length;index++){
300 | 					summary_selector+=", "+condition.value[index]+":checked";
301 | 				}
302 | 				summary_selector=summary_selector.substr(1);
303 | 				
304 | 				if (condition.selector!=='') {//Задан селектор внешнего поля, дополнительно вешаем обработчик на него
305 | 					if (condition.min) {//Генерируем условие для min, если оно задано
306 | 						_condition+=" && ($('"+condition.selector+summary_selector+"').length >= "+condition.min+")";
307 | 					}
308 | 					if (condition.max) {//Генерируем условие для max, если оно задано
309 | 						_condition+=" && ($('"+condition.selector+summary_selector+"').length <= "+condition.max+")";
310 | 					}
311 | 					ret.condition = "is_fields_checked($('"+condition.selector+"'),"+ JSON.stringify(condition.value)+","+condition.strict+")"+_condition;
312 | 					/*Для блоков требуется эмулировать onchange, поэтому передаём вот такой селектор*/
313 | 					ret.handler.push("$('"+condition.selector+"').find('input[type=checkbox], input[type=radio]')");
314 | 				} else {//Селектор не задан, проверяем собственное поле
315 | 					if (condition.min) {//Генерируем условие для min, если оно задано
316 | 						_condition+=" && (field.find('"+summary_selector+"').length >= "+condition.min+")";
317 | 					}
318 | 					if (condition.max) {//Генерируем условие для max, если оно задано
319 | 						_condition+=" && (field.find('"+summary_selector+"').length <= "+condition.max+")";
320 | 					}
321 | 					ret.condition = "is_fields_checked(field,"+ JSON.stringify(condition.value)+","+condition.strict+")"+_condition;
322 | 					/*Для блоков требуется эмулировать onchange, поэтому передаём вот такой селектор*/
323 | 					ret.handler.push("field.find('input[type=checkbox], input[type=radio]')");
324 | 				}
325 | 			break;
326 | 			case 'native':
327 | 				ret.condition=condition.value;
328 | 				if (condition.selector!=='') { //Задан селектор внешнего поля, дополнительно вешаем обработчик на него
329 | 					ret.handler.push("$('"+condition.selector+"')");
330 | 				}
331 | 			break;
332 | 		}
333 | 		ret.handler.push("field");
334 | 		if (condition.invert) {
335 | 			ret.condition=condition.logic+" !("+ret.condition+")";
336 | 		} else {
337 | 			ret.condition=condition.logic+" ("+ret.condition+")";
338 | 		}
339 | 		return (ret);
340 | 		
341 | 	}
342 | 
343 | 	/*
344 | 	 * field - jQuery-объект поля, к которому применяется правило
345 | 	 * rule - применяемое правило
346 | 	 * conditions - набор условий, при которых правило применяется
347 | 	*/
348 | 	function apply_rule(field,rule,conditions){
349 | 		var summary_conditions={
350 | 			condition:"",
351 | 			handler:[]
352 | 		},
353 | 		js_condition,i,h,condition, action;
354 | 		for (condition in conditions){
355 | 			if ($.isNumeric(condition)) js_condition=get_js_condition(conditions[condition],field);//В conditions может быть нецифровой параметр, дополняющий набор правил
356 | 			summary_conditions.condition+=" "+js_condition.condition;
357 | 			for (i=0;i<js_condition.handler.length;i++){//Избавляемся от навешиваний одинаковых обработчиков на одно поле
358 | 				if (!summary_conditions.handler.object_in_array(js_condition.handler[i])) summary_conditions.handler.push(js_condition.handler[i]);
359 | 			}
360 | 		}
361 | 		//Обрезаем от условия первые четыре символа с первым ненужным условием. Если будет глючить - переписать регуляркой.
362 | 		summary_conditions.condition=summary_conditions.condition.substr(4);
363 | 		for (i=0;i<summary_conditions.handler.length;i++){
364 | 			h=(summary_conditions.handler[i]==='')?field:eval(summary_conditions.handler[i]);//На всякий случай
365 | 			
366 | 			action=get_rule_action(rule,conditions.actions);//Получим событие, заданное в правиле непосредственно 
367 | 			action+=" "+get_rule_action(rule,ACCEPTABLE.actions);//Получим событие, заданное для всех правил
368 | 			
369 | 			switch (checkable(h)){//Получим глобальное правило + правила для "особенных" элементов
370 | 				case 0:
371 | 					action+=" "+ ACCEPTABLE.action;
372 | 				break;
373 | 				case 1:
374 | 					action= "change";
375 | 				break;
376 | 				case 2://С радиокнопками всё плохо, у них нет нормального onChange
377 | 					if (typeof(h.attr('name'))!=='undefined') h=$('input[name="'+h.attr('name')+'\"]');
378 | 					action+=" "+ "change";
379 | 				break;
380 | 				case 3://Для селектов нужно обрабатывать оба события
381 | 					action+=" "+ ACCEPTABLE.action+" change";
382 | 				break;
383 | 			}
384 | 			
385 | 			action=action.trim();
386 | 			
387 | 			h.on(action,function(event,ignore_change,ignore_action){
388 | 				var x=set_class(field,rule,eval(summary_conditions.condition));
389 | 				if (x) {
390 | 					h.trigger(x.action+x.rule);
391 | 				}
392 | 				
393 | 				if (!ignore_action || typeof(ignore_action)==='undefined') {//вызываем срабатывании функции в onAction только для реально произошедших событий, а не для вызванных в коде
394 | 					if (ACCEPTABLE.onAction) ACCEPTABLE.onAction(field);
395 | 				}
396 | 				initiateEvents(FORM);
397 | 				
398 | 				if (!ignore_change || typeof(ignore_change)==='undefined') {//вызываем изменение состояний changed/unchanged только для реально произошедших событий, а не для вызванных в коде
399 | 					if (ACCEPTABLE.classUnchanged!==false)h.removeClass(ACCEPTABLE.classUnchanged);
400 | 					if (ACCEPTABLE.classChanged!==false) h.addClass(ACCEPTABLE.classChanged);
401 | 				}
402 | 			});
403 | 			
404 | 			if (ACCEPTABLE.classUnchanged!==false) h.addClass(ACCEPTABLE.classUnchanged);
405 | 			
406 | 			if (ACCEPTABLE.autograb) {
407 | 				var a=action.split(' ');
408 | 				$(a).each (function(val){
409 | 					h.trigger(a[val],[ACCEPTABLE.ignore_autograb_change,ACCEPTABLE.ignore_autograb_action]);//Инициализация состояния
410 | 				});
411 | 			}
412 | 		}
413 | 	}
414 | 	
415 | 	function get_rule_action(rule,actions) {
416 | 		if (typeof(actions)==='undefined') return "";
417 | 		return(actions[rule.toLowerCase()]||"");
418 | 	}
419 | 	
420 | 	//Возвращает true, если переданный элемент поддерживает только onChange
421 | 	function checkable(field){
422 | 		//TODO: Проверить, что будет, если в field много полей
423 | 		if (field.is('[type=checkbox]')) {
424 | 			return (1);
425 | 		} else if (field.is('[type=radio]')) {
426 | 			return (2)
427 | 		} else if (field.is('select')) {
428 | 			return (3);
429 | 		} else return (0);
430 | 	}
431 | 	/**
432 | 	 * Проверяет, произошло ли переключение состояния для valid и required, если произошло - инициирует соответствующее событие. Состояние visible проверяется непосредственно в setClass
433 | 	**/
434 | 	function initiateEvents(lemonform){
435 | 		var	cur_valid=lemonform.isValid(),
436 | 				cur_require=!lemonform.isNotRequired(),
437 | 				cur_visible=lemonform.is(':visible');
438 | 		if (cur_valid && !ValidState) {
439 | 			lemonform.trigger('lemongrab.valid');
440 | 			ValidState=true;
441 | 		} else if (!cur_valid && ValidState) {
442 | 			lemonform.trigger('lemongrab.novalid');
443 | 			ValidState=false;
444 | 		}
445 | 		if (cur_require && !RequiredState) {
446 | 			lemonform.trigger('lemongrab.require');
447 | 			RequiredState=true;
448 | 		} else if (!cur_require && RequiredState) {
449 | 			lemonform.trigger('lemongrab.norequire');
450 | 			RequiredState=false;
451 | 		}
452 | 	}
453 | 	
454 | 	//Проверяет, есть ли точно такой же объект в массиве (вплоть до значений полей).
455 | 	Array.prototype.object_in_array = function(srch) {
456 | 		var i;
457 | 		for(i=0; i < this.length; i++) {
458 | 			if (typeof(this[i])==='object'){
459 | 				//Обойдёмся без рекурсии. Если понадобится рекурсия: http://javascript.ru/forum/misc/10792-sravnenie-obektov-2.html#post209343
460 | 				if (JSON.stringify(this[i])===JSON.stringify(srch)) {
461 | 					return true;
462 | 				}
463 | 			}
464 | 		}
465 | 		return false;
466 | 	};
467 | 	
468 | 	/*
469 | 	 * Сравнивает двумерные массивы между собой. Массивы трактуются как множества - т.е. одинаковыми считаются массивы с равным количеством элементов и их одинаковыми значениями, но порядок элементов может быть разный, т.е. [1,2,3]===[2,1,3]
470 | 	 * strict задаёт строгость вхождения. false - array может быть подмножеством, true - должен точно совпадать
471 | 	*/
472 | 	Array.prototype.equals = function (array,strict){
473 | 		if (typeof(strict)==='undefined') strict=false;
474 | 		if ((strict && this.length!==array.length)||(!strict && this.length>array.length)) return (false);
475 | 		
476 | 		var i;
477 | 		if (!Array.prototype.indexOf) {/*честно скопипащено из интернетов и не проверялось, т.к. все современные браузеры должны поддерживать indexOf*/
478 | 			Array.prototype.indexOf = function(elt /*, from*/) {
479 | 				var len = this.length >>> 0;
480 | 				var from = Number(arguments[1]) || 0;
481 | 				from = (from < 0) ? Math.ceil(from) : Math.floor(from);
482 | 				if (from < 0) from += len;
483 | 				for (; from < len; from++){
484 | 					if (from in this && this[from] === elt) return from;
485 | 				}
486 | 				return -1;
487 | 			};
488 | 		}
489 | 		
490 | 		for (i=0;i<this.length;i++){
491 | 			if(array.indexOf(this[i])===-1) return (false);
492 | 		}
493 | 		return (true);
494 | 	};
495 | 	
496 | 	/**
497 | 	 * Меняет класс и сообщает, произошло ли изменение состояния.
498 | 	 */
499 | 
500 | 	function set_class(field,rule,setc){
501 | 		var ret=false;
502 | 		var positiveClass,negativeClass;
503 | 		if (typeof(rule)==='undefined') return(0);
504 | 		switch (rule){
505 | 			case 'VALID':
506 | 				positiveClass=ACCEPTABLE.classValid;
507 | 				negativeClass=ACCEPTABLE.classInvalid;
508 | 			break;
509 | 			case 'REQUIRED':
510 | 				positiveClass=ACCEPTABLE.classRequired;
511 | 				negativeClass=ACCEPTABLE.classNorequired;
512 | 			break;
513 | 			case 'ENABLED':
514 | 				positiveClass=ACCEPTABLE.classEnabled;
515 | 				negativeClass=ACCEPTABLE.classDisabled;
516 | 			break;
517 | 			case 'VISIBLE':
518 | 				positiveClass=ACCEPTABLE.classVisible;
519 | 				negativeClass=ACCEPTABLE.classHidden;
520 | 			break;
521 | 		}
522 | 		if(setc){
523 | 			if (field.hasClass(negativeClass)) {
524 | 				ret={
525 | 					"rule":rule,
526 | 					"action":"SET"
527 | 				}
528 | 			}
529 | 		
530 | 			field.removeClass(negativeClass).addClass(positiveClass);
531 | 			if (rule==='REQUIRED' && ACCEPTABLE.useRequiredAttr) field.attr("required","required");
532 | 			if (rule==='ENABLED' && ACCEPTABLE.nativeEnabled ) field.removeAttr("disabled");
533 | 			if (rule==='VISIBLE' && ACCEPTABLE.nativeVisible) {
534 | 				field.show();
535 | 				field.trigger('lemongrab.visible');
536 | 			}
537 | 		} else {
538 | 		
539 | 			if (field.hasClass(positiveClass)) {
540 | 				ret={
541 | 					"rule":rule,
542 | 					"action":"REMOVE"
543 | 				}
544 | 			}
545 | 		
546 | 			field.removeClass(positiveClass).addClass(negativeClass);
547 | 			if (rule==='REQUIRED' && ACCEPTABLE.useRequiredAttr) field.removeAttr("required");
548 | 			if (rule==='ENABLED' && ACCEPTABLE.nativeEnabled ) field.attr("disabled","disabled");
549 | 			if (rule==='VISIBLE' && ACCEPTABLE.nativeVisible) {
550 | 				field.hide();
551 | 				field.trigger('lemongrab.hide');
552 | 			}
553 | 		}
554 | 		return (ret);
555 | 	}
556 | 
557 | }( jQuery ));
558 | 


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