Reworked destroy srategy

Work in progress. Changed option to alway be a string
and also stopped destruction on external event by a flag
on scope.

Author: davidlgj

docs/index.md

@@ -636,7 +636,7 @@ General options most field types can handle:
   labelHtmlClass: "street"     // CSS Class(es) to be added to the label of the field (or similar)
   copyValueTo: ["address.street"],     // Copy values to these schema keys.
   condition: "person.age < 18" // Show or hide field depending on an angular expression
-  destroyStrategy: null        // One of null, empty string, undefined, or 'retain'. Changes model on $destroy event.
+  destroyStrategy: "remove"    // One of "null", "empty" , "remove", or 'retain'. Changes model on $destroy event. default is "remove".
 }
 ```
 
@@ -827,14 +827,23 @@ Note that arrays inside arrays won't work with conditions.
 
 
 ### destroyStrategy
-By default, when a field is removed from the DOM and the $destroy event is broadcast, the schema-validate directive 
-will update the model to set the field value to undefined. This can be overridden by setting the destroyStrategy 
-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 [globalOptions](#global-options)
+By default, when a field is removed from the DOM and the `$destroy` event is broadcast, this happens
+if you use the `condition` option, the schema-validate directive will update the model to set the
+field value to `undefined`. This can be overridden by setting the destroyStrategy on a field, or as a
+global option, to one of the strings `"null"`, `"empty"` , `"remove"`, or `"retain"`.
+
+`"null"` means that model values will be set to `null` instead of being removed.
+
+`"empty"` means empty strings, `""`, for model values that has the `string` type, `{}` for model
+  values with `object` type and `[]` for `array` type. All other types will be treated as `"remove"`.
 
+`"remove"` deletes the property. This is the default.
 
+`"retain"` keeps the value of the property event though the field is no longer in the form or being
+vaidated before submit.
+
+If you'd like to set the destroyStrategy for
+an entire form, add it to the [globalOptions](#global-options)
 
 
 Specific options and types
@@ -1581,7 +1590,7 @@ function FormCtrl($scope) {
     "eligible",
     {
         type: "conditional",
-        condition: "model.person.eligible", 
+        condition: "model.person.eligible",
         items: [
           "code"
         ]

src/directives/schema-form.js

@@ -72,7 +72,10 @@ angular.module('schemaForm')
           // they have been removed from the DOM
           // https://github.com/Textalk/angular-schema-form/issues/200
           if (childScope) {
+            // Destroy strategy should not be acted upon
+            scope.externalDestructionInProgress = true;
             childScope.$destroy();
+            scope.externalDestructionInProgress = false;
           }
           childScope = scope.$new();
 
@@ -162,7 +165,16 @@ angular.module('schemaForm')
         });
 
         scope.$on('$destroy', function() {
-          sfRetainModel.setFlag(true);
+          console.log('Total schema form destruction in progress.');
+          // Each field listens to the $destroy event so that it can remove any value
+          // from the model if that field is removed from the form. This is the default
+          // destroy strategy. But if the entire form (or at least the part we're on)
+          // gets removed, like when routing away to another page, then we definetly want to
+          // keep the model intact. So therefore we set a flag to tell the others it's time to just
+          // let it be.
+          scope.externalDestructionInProgress = true;
+          //scope.$broadcast('externalDestroy')
+          //sfRetainModel.setFlag(true);
         });
       }
     };

src/directives/schema-validate.js

@@ -103,7 +103,7 @@ angular.module('schemaForm').directive('schemaValidate', ['sfValidator', 'sfSele
         });
 
 
-        var DEFAULT_DESTROY_STRATEGY = getGlobalOptionsDestroyStrategy();
+        /*var DEFAULT_DESTROY_STRATEGY = getGlobalOptionsDestroyStrategy();
 
         function getGlobalOptionsDestroyStrategy() {
           var defaultStrategy = undefined;
@@ -122,14 +122,49 @@ angular.module('schemaForm').directive('schemaValidate', ['sfValidator', 'sfSele
             }
           }
           return defaultStrategy;
-        }
+        }*/
+
 
         // Clean up the model when the corresponding form field is $destroy-ed.
         // Default behavior can be supplied as a globalOption, and behavior can be overridden in the form definition.
         scope.$on('$destroy', function() {
+          console.log('Schema validate destroy', scope.externalDestructionInProgress);
+
+          // If the entire schema form is destroyed we don't touch the model
+          if (!scope.externalDestructionInProgress) {
+            var form = getForm();
+            var destroyStrategy = form.destroyStrategy ||
+                                  (scope.options && scope.options.destroyStrategy) || 'remove';
+            console.log('going with destroy strategy ', destroyStrategy, scope.options)
+            // No key no model, and we might have strategy 'retain'
+            if (form.key && destroyStrategy !== 'retain') {
+
+              // Get the object that has the property we wan't to clear.
+              var obj = scope.model;
+              if (form.key.length > 1) {
+                obj = sfSelect(form.key.slice(0, form.key.length - 1), obj);
+              }
+
+              // Type can also be a list in JSON Schema
+              var type = (form.schema && form.schema.type) || '';
+
+              // Empty means '',{} and [] for appropriate types and undefined for the rest
+              if (destroyStrategy === 'empty' && type.indexOf('string') !== -1) {
+                obj[form.key.slice(-1)] = '';
+              } else if (destroyStrategy === 'empty' && type.indexOf('object') !== -1) {
+                obj[form.key.slice(-1)] = {};
+              } else if (destroyStrategy === 'empty' && type.indexOf('array') !== -1) {
+                obj[form.key.slice(-1)] = [];
+              } else if (destroyStrategy === 'null') {
+                obj[form.key.slice(-1)] = null;
+              } else {
+                delete obj[form.key.slice(-1)];
+              }
+            }
+          }
+
 
-          var form = getForm();
-          var conditionResult = $parse(form.condition);
+          /*var conditionResult = $parse(form.condition);
           var formModelNotRetained = !sfRetainModel.getFlag();
 
           // If condition is defined and not satisfied and the sfSchema model should not be retained.
@@ -166,18 +201,8 @@ angular.module('schemaForm').directive('schemaValidate', ['sfValidator', 'sfSele
               }
               sfUnselect(scope.form.key, scope.model, strategy);
             }
-
-            function getSchemaType() {
-              var sType;
-              if (form.schema) {
-                sType = form.schema.type;
-              }
-              else {
-                sType = null;
-              }
-              return sType;
-            }
           }
+          */
         });