Fixes from code review in #371. Reworked the default destroyStrategy to be picked up directly from globalOptions, instead of looking in formDefaults. Properly handles for the difference between the destroyStrategy declared as undefined and completely undeclared, both at the globalOptions level and the form field definition level.

Author: jbsaff

docs/index.md

@@ -193,6 +193,7 @@ attribute which should be placed along side `sf-schema`.
 | formDefaults | an object that will be used as a default for all form definitions |
 | validationMessage | an object or a function that will be used as default validation message for all fields. See [Validation Messages](#validation-messages) for details. |
 | setSchemaDefaults | boolean, set to false an no defaults from the schema will be set on the model. |
+| destroyStrategy | the default strategy to use for cleaning the model when a form element is removed. see [destroyStrategy](#destroyStrategy) below |
 
 *formDefaults* is mostly useful for setting global [ngModelOptions](#ngmodeloptions)
 i.e. changing the entire form to validate on blur.
@@ -831,7 +832,7 @@ will update the model to set the field value to undefined. This can be overridde
 on a field to one of null, empty string (""), undefined, or "retain". Any other value will be ignored and the default  
 behavior will apply. The empty string option only applies to fields that have a type of string; using the empty string 
 with other field types will just be set to the default destroyStrategy. If you'd like to set the destroyStrategy for 
-an entire form, add it to the formDefaults in the [globalOptions](#global-options)
+an entire form, add it to the [globalOptions](#global-options)
 
 
 

src/directives/schema-validate.js

@@ -103,62 +103,75 @@ angular.module('schemaForm').directive('schemaValidate', ['sfValidator', 'sfSele
         });
 
 
-        var DEFAULT_DESTROY_STRATEGY;
-        if (scope.options && scope.options.formDefaults) {
-          var formDefaultDestroyStrategy = scope.options.formDefaults.destroyStrategy;
-          var isValidFormDefaultDestroyStrategy = (formDefaultDestroyStrategy === undefined ||
-          formDefaultDestroyStrategy === '' ||
-          formDefaultDestroyStrategy === null ||
-          formDefaultDestroyStrategy === 'retain');
-          if (isValidFormDefaultDestroyStrategy) {
-            DEFAULT_DESTROY_STRATEGY = formDefaultDestroyStrategy;
-          }
-          else {
-            console.warn('Unrecognized formDefaults.destroyStrategy: \'%s\'. Used undefined instead.',
-                formDefaultDestroyStrategy);
-            DEFAULT_DESTROY_STRATEGY = undefined;
+        var DEFAULT_DESTROY_STRATEGY = getGlobalOptionsDestroyStrategy();
+
+        function getGlobalOptionsDestroyStrategy() {
+          var defaultStrategy = undefined;
+          if (scope.options && scope.options.hasOwnProperty('destroyStrategy')) {
+            var globalOptionsDestroyStrategy = scope.options.destroyStrategy;
+            var isValidFormDefaultDestroyStrategy = (globalOptionsDestroyStrategy === undefined ||
+                                                    globalOptionsDestroyStrategy === '' ||
+                                                    globalOptionsDestroyStrategy === null ||
+                                                    globalOptionsDestroyStrategy === 'retain');
+            if (isValidFormDefaultDestroyStrategy) {
+              defaultStrategy = globalOptionsDestroyStrategy;
+            }
+            else {
+              console.warn('Unrecognized globalOptions destroyStrategy: %s \'%s\'. Used undefined instead.',
+                  typeof globalOptionsDestroyStrategy, globalOptionsDestroyStrategy);
+            }
           }
+          return defaultStrategy;
         }
 
         // Clean up the model when the corresponding form field is $destroy-ed.
-        // Default behavior can be supplied as a formDefault, and behavior can be overridden in the form definition.
+        // Default behavior can be supplied as a globalOption, and behavior can be overridden in the form definition.
         scope.$on('$destroy', function() {
           var form = getForm();
-          var destroyStrategy = form.destroyStrategy; // Either set in form definition, or as part of formDefaults.
+
+          // Either set in form definition, or as part of globalOptions.
+          var destroyStrategy =
+              !form.hasOwnProperty('destroyStrategy') ? DEFAULT_DESTROY_STRATEGY : form.destroyStrategy;
           var schemaType = getSchemaType();
 
           if (destroyStrategy && destroyStrategy !== 'retain' ) {
             // Don't recognize the strategy, so give a warning.
-            console.warn('Unrecognized destroyStrategy: \'%s\'. Used default instead.', destroyStrategy);
+            console.warn('%s has defined unrecognized destroyStrategy: \'%s\'. Used default instead.',
+                attrs.name, destroyStrategy);
             destroyStrategy = DEFAULT_DESTROY_STRATEGY;
           }
           else if (schemaType !== 'string' && destroyStrategy === '') {
             // Only 'string' type fields can have an empty string value as a valid option.
-            console.warn('Attempted to use empty string destroyStrategy on non-string form type. Used default instead.');
+            console.warn('%s attempted to use empty string destroyStrategy on non-string form type. ' +
+                'Used default instead.', attrs.name);
             destroyStrategy = DEFAULT_DESTROY_STRATEGY;
           }
 
           if (destroyStrategy === 'retain') {
             return; // Valid option to avoid destroying data in the model.
           }
+          console.log('result %s', destroyStrategy);
 
           destroyUsingStrategy(destroyStrategy);
 
           function destroyUsingStrategy(strategy) {
-            var strategyIsDefined = (strategy === null || strategy === '' || typeof strategy == undefined);
+            console.log('Destroy called with %s', strategy);
+            var strategyIsDefined = (strategy === null || strategy === '' || strategy === undefined);
             if (!strategyIsDefined){
               strategy = DEFAULT_DESTROY_STRATEGY;
             }
             sfUnselect(scope.form.key, scope.model, strategy);
           }
 
           function getSchemaType() {
+            var sType;
             if (form.schema) {
-              schemaType = form.schema.type;
+              sType = form.schema.type;
             }
             else {
-              schemaType = null;
+              sType = null;
             }
+            return sType;
           }
         });