Iron out some creases in validation

* schemaFormValidate used model value for validation, so any ordinary validation message got changed to "required".
  This was since we validated the model value, we can't validate the viewValue since numbers wouldn't work. So we
  set the viewValue again to trigger parsers. This works fine in Angular 1.2 and in 1.3 it solves the problem, but
  introduces another. When setting the viewValue `undefined` in 1.2 we get a nice "required", but in 1.3 parsers
  aren't even called. So we add an extra check with required and ngModel.$isEmpty()
* In Angular 1.3 returning undefined from a parser automatically tacks on a 'parse' error. Instead we always return
  the viewValue and later in a special validator ('schemaForm') stop the model from getting updated. 'schemaForm'
  error gets filtered so it never hits the forms. In Angular 1.2 we return undefined since that doesn't tack on a
  'parse' error.

Author: davidlgj

src/directives/message.js

@@ -21,13 +21,20 @@ angular.module('schemaForm').directive('sfMessage',
           element.html(msg);
         } else {
 
-          var errors = Object.keys(
-            (scope.ngModel && scope.ngModel.$error) || {}
-          );
 
-          // Since we use $parsers to hook up our validation we also end up with a "parse" error.
-          // so we remove it.
-          errors = errors.filter(function(e) { return e !== 'parse'; });
+          var errors = [];
+          angular.forEach(((scope.ngModel && scope.ngModel.$error) || {}), function(status, code) {
+            if (status) {
+              // if true then there is an error
+              // Angular 1.3 removes properties, so we will always just have errors.
+              // Angular 1.2 sets them to false.
+              errors.push(code);
+            }
+          });
+
+          // In Angular 1.3 we use one $validator to stop the model value from getting updated.
+          // this means that we always end up with a 'schemaForm' error.
+          errors = errors.filter(function(e) { return e !== 'schemaForm'; });
 
           // We only show one error.
           // TODO: Make that optional

src/directives/schema-validate.js

@@ -46,6 +46,8 @@ angular.module('schemaForm').directive('schemaValidate', ['sfValidator', '$parse
             }
 
             var result =  sfValidator.validate(form, viewValue);
+
+
             // Since we might have different tv4 errors we must clear all
             // errors that start with tv4-
             Object.keys(ngModel.$error)
@@ -56,6 +58,15 @@ angular.module('schemaForm').directive('schemaValidate', ['sfValidator', '$parse
               // it is invalid, return undefined (no model update)
               ngModel.$setValidity('tv4-' + result.error.code, false);
               error = result.error;
+
+              // In Angular 1.3+ return the viewValue, otherwise we inadvertenly
+              // will trigger a 'parse' error.
+              // we will stop the model value from updating with our own $validator
+              // later.
+              if (ngModel.$validators) {
+                return viewValue;
+              }
+              // Angular 1.2 on the other hand lacks $validators and don't add a 'parse' error.
               return undefined;
             }
             return viewValue;
@@ -75,7 +86,7 @@ angular.module('schemaForm').directive('schemaValidate', ['sfValidator', '$parse
           });
 
           ['$validators', '$asyncValidators'].forEach(function(attr) {
-            // Check if our version of angular has i, i.e. 1.3+
+            // Check if our version of angular has validators, i.e. 1.3+
             if (form[attr] && ngModel[attr]) {
               angular.forEach(form[attr], function(fn, name) {
                 ngModel[attr][name] = fn;
@@ -84,17 +95,41 @@ angular.module('schemaForm').directive('schemaValidate', ['sfValidator', '$parse
           });
 
           // Get in last of the parses so the parsed value has the correct type.
-          // We don't use $validators since we like to set different errors depeding tv4 error codes
+          // We don't use $validators since we like to set different errors depending tv4 error codes
           ngModel.$parsers.push(validate);
 
+          // But we do use one custom validator in the case of Angular 1.3 to stop the model from
+          // updating if we've found an error.
+          if (ngModel.$validators) {
+            ngModel.$validators.schemaForm = function() {
+              // Any error and we're out of here!
+              return !Object.keys(ngModel.$error).some(function(e) { return e !== 'schemaForm'});
+            }
+          }
+
           // Listen to an event so we can validate the input on request
           scope.$on('schemaFormValidate', function() {
+
+            // We set the viewValue to trigger parsers,
+            // since modelValue might be empty and validating just that
+            // might change an existing error to a "required" error message.
             if (ngModel.$setDirty) {
+
               // Angular 1.3+
               ngModel.$setDirty();
-              validate(ngModel.$modelValue);
+              ngModel.$setViewValue(ngModel.$viewValue);
+              ngModel.$commitViewValue();
+
+              // In Angular 1.3 setting undefined as a viewValue does not trigger parsers
+              // so we need to do a special required check. Fortunately we have $isEmpty
+              if (form.required && ngModel.$isEmpty()) {
+                ngModel.$setValidity('tv4-302', false);
+              }
+
             } else {
               // Angular 1.2
+              // In angular 1.2 setting a viewValue of undefined will trigger the parser.
+              // hence required works.
               ngModel.$setViewValue(ngModel.$viewValue);
             }
 

src/services/builder.js

@@ -134,7 +134,6 @@ var transclusion = function() {
        * Builds a form from a canonical form definition
        */
       build: function(form, decorator, slots) {
-console.warn(slots)
         return build(form, decorator, function(url) {
           return $templateCache.get(url) || '';
         }, slots);