glib-web 4.1.2 → 4.1.3

package/components/fields/checkGroup.vue

@@ -8,7 +8,7 @@
     <template v-if="values.length > 0">
       <input type="hidden" v-for="(value, index) in values" :value="value" :key="index" :name="fieldName" />
     </template>
-    <input v-else type="hidden" :name="fieldName" :value="null" />
+    <input v-else type="hidden" :name="fieldName" :value="spec.uncheckValue" />
   </div>
 </template>
 

package/components/mixins/generic.js

@@ -1,4 +1,5 @@
 import { vueApp } from "../../store";
+import { ValidationFactory } from "../validation";
 
 export default {
   methods: {
@@ -24,26 +25,9 @@ export default {
     $validation(rules) {
       var augmentedRules = rules || [];
       Utils.type.ifObject(this.spec.validation, val => {
-        Utils.type.ifObject(val.required, spec => {
-          const validationFunc = (v) => {
-            if (!Utils.type.isNotNull(v)) return spec.message;
-            if (Array.isArray(v) && v.length <= 0) return spec.message;
-            if (Utils.type.isString(v) && v.length <= 0) return spec.message;
-
-
-            return true;
-          };
-          augmentedRules = augmentedRules.concat([validationFunc]);
-        });
-        Utils.type.ifObject(val.format, spec => {
-          augmentedRules = augmentedRules.concat([
-            v => {
-              if (v && !v.toString().match(spec.regex)) {
-                return spec.message;
-              }
-              return true;
-            }
-          ]);
+        Object.keys(val).forEach((key) => {
+          const validator = ValidationFactory.getValidator(key, val[key]);
+          augmentedRules = augmentedRules.concat([validator.build.bind(validator)]);
         });
       });
       return augmentedRules;

package/components/validation.js

@@ -0,0 +1,179 @@
+class AbstractValidator {
+  constructor(validationOptions) {
+    this.validationOptions = validationOptions;
+  }
+
+  build(model) {
+    return true;
+  }
+
+  isAllowBlank() {
+    return !!this.validationOptions.allow_blank || !!this.validationOptions.allow_nil;
+  }
+}
+
+function isPresent(value) {
+  if (value == undefined) return false;
+  if (value == null) return false;
+  if (Array.isArray(value) && value.length <= 0) return false;
+  if (typeof value == 'string' && value.length <= 0) return false;
+  if (typeof value == 'object' && Object.keys(value).length <= 0) return false;
+
+  return true;
+}
+
+class PresenceValidator extends AbstractValidator {
+  build(model) {
+    return isPresent(model) ? true : this.validationOptions.message;
+  }
+}
+class RequiredValidator extends PresenceValidator { }
+
+class AbsenceValidator extends AbstractValidator {
+  build(model) {
+    return !isPresent(model) ? true : this.validationOptions.message;
+  }
+}
+
+class AcceptanceValidator extends AbstractValidator {
+  build(model) {
+    if (this.isAllowBlank() && !isPresent(model)) return true;
+
+    const { accept } = this.validationOptions;
+    return accept.includes(model) ? true : this.validationOptions.message;
+  }
+}
+
+class NumericalityValidator extends AbstractValidator {
+  build(model) {
+    if (this.isAllowBlank() && !isPresent(model)) return true;
+
+    let result = true;
+    ['greater_than', 'greater_than_or_equal_to', 'equal_to', 'less_than', 'less_than_or_equal_to', 'other_than', 'odd', 'even'].forEach((key) => {
+      let count = this.validationOptions[key];
+      if (!isPresent(count)) return;
+      if (this.validate(key, count, model)) return;
+
+      result = this.errorMessage(key, count);
+    });
+
+    return result;
+  }
+
+  validate(key, count, value) {
+    const obj = {
+      'greater_than': () => count < value,
+      'greater_than_or_equal_to': () => count <= value,
+      'equal_to': () => count == value,
+      'less_than': () => count > value,
+      'less_than_or_equal_to': () => count >= value,
+      'other_than': () => count != value,
+      'in': () => count.includes(value),
+      'odd': () => value % 2 == 1,
+      'even': () => value % 2 == 0
+    };
+
+    return obj[key]();
+  }
+
+  errorMessage(key, count) {
+    const message = this.validationOptions.message;
+    if (typeof message == 'string') return message;
+
+    return message[key].replace('%{count}', count);
+  }
+}
+
+class FormatValidator extends AbstractValidator {
+  build(model) {
+    if (this.isAllowBlank() && !isPresent(model)) return true;
+
+    const regex = this.validationOptions.with || this.validationOptions.without || this.validationOptions.regex;
+    let match = !!(model || '').match(regex);
+    match = this.isInverse() ? !match : match;
+
+    return match ? true : this.validationOptions.message;
+  }
+
+  isInverse() {
+    return !!this.validationOptions.without;
+  }
+}
+
+class InclusionValidator extends AbstractValidator {
+  build(model) {
+    if (this.isAllowBlank() && !isPresent(model)) return true;
+
+    const within = this.validationOptions.in || this.validationOptions.within;
+
+    return within.includes(model) ? true : this.validationOptions.message;
+  }
+}
+
+class ExclusionValidator extends AbstractValidator {
+  build(model) {
+    if (this.isAllowBlank() && !isPresent(model)) return true;
+
+    const within = this.validationOptions.in || this.validationOptions.within;
+
+    return !within.includes(model) ? true : this.validationOptions.message;
+  }
+}
+
+class LengthValidator extends AbsenceValidator {
+  build(model) {
+    model ||= '';
+    if (this.isAllowBlank() && !isPresent(model)) return true;
+
+    const { minimum, maximum } = this.validationOptions;
+    let result;
+    if (isPresent(minimum)) {
+      result = model.length > minimum ? true : this.errorMessage('too_short', minimum);
+    }
+    if (result !== true) return result;
+    if (isPresent(maximum)) {
+      result = model.length < maximum ? true : this.errorMessage('too_long', maximum);
+    }
+    if (result !== true) return result;
+    if (isPresent(this.validationOptions.is)) {
+      result = model.length === this.validationOptions.is ? true : this.errorMessage('wrong_length', this.validationOptions.is);
+    }
+    if (result !== true) return result;
+    if (isPresent(this.validationOptions.in)) {
+      result = (model.length >= this.validationOptions.is || model.length <= this.validatorOptions.is) ? true : this.errorMessage('wrong_length', this.validationOptions.in);
+    }
+
+    return result;
+  }
+
+  errorMessage(key, count) {
+    const message = this.validationOptions.message;
+    const singular = count <= 1;
+    if (typeof message == 'string') {
+      return message.replace('%{count}', count);
+    }
+
+    return message[key][singular ? 'one' : 'other'].replace('%{count}', count);
+  }
+}
+
+const clsMap = {
+  'absence': AbsenceValidator,
+  'presence': PresenceValidator,
+  'required': RequiredValidator,
+  'acceptance': AcceptanceValidator,
+  'numericality': NumericalityValidator,
+  'format': FormatValidator,
+  'inclusion': InclusionValidator,
+  'exclusion': ExclusionValidator,
+  'length': LengthValidator
+};
+
+class ValidationFactory {
+  static getValidator(validatorName, validatorOptions) {
+    return new clsMap[validatorName](validatorOptions);
+  }
+}
+
+export { ValidationFactory }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glib-web",
-  "version": "4.1.2",
+  "version": "4.1.3",
   "description": "",
   "main": "index.js",
   "scripts": {