Revert a31cdbe..7b53c63

This rolls back to commit a31cdbe.

Author: jbsaff

docs/index.md

@@ -634,6 +634,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: ''          // Update the model when the field is destoyed, e.g. when condition is not longer satisfied.
 }
 ```
 
@@ -823,6 +824,14 @@ function FormCtrl($scope) {
 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 formDefaults in the [globalOptions](#global-options)
+
 
 
 Specific options and types

src/directives/schema-validate.js

@@ -1,4 +1,6 @@
-angular.module('schemaForm').directive('schemaValidate', ['sfValidator', 'sfSelect', function(sfValidator, sfSelect) {
+angular.module('schemaForm').directive('schemaValidate', ['sfValidator', 'sfSelect', 'sfUnselect',
+  function(sfValidator, sfSelect, sfUnselect) {
+
   return {
     restrict: 'A',
     scope: false,
@@ -8,7 +10,6 @@ angular.module('schemaForm').directive('schemaValidate', ['sfValidator', 'sfSele
     require: 'ngModel',
     link: function(scope, element, attrs, ngModel) {
 
-
       // We need the ngModelController on several places,
       // most notably for errors.
       // So we emit it up to the decorator directive so it can put it on scope.
@@ -101,6 +102,68 @@ 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;
+        }
+      }
+
+      // 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.
+      scope.$on('$destroy', function() {
+        var form = getForm();
+        var destroyStrategy = form.destroyStrategy; // Either set in form definition, or as part of formDefaults.
+        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);
+          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.');
+          destroyStrategy = DEFAULT_DESTROY_STRATEGY;
+        }
+
+        if (destroyStrategy === 'retain') {
+          return; // Valid option to avoid destroying data in the model.
+        }
+
+        destroyUsingStrategy(destroyStrategy);
+
+        function destroyUsingStrategy(strategy) {
+          var strategyIsDefined = (strategy === null || strategy === '' || typeof strategy == undefined);
+          if (!strategyIsDefined){
+            strategy = DEFAULT_DESTROY_STRATEGY;
+          }
+          sfUnselect(scope.form.key, scope.model, strategy);
+        }
+
+        function getSchemaType() {
+          if (form.schema) {
+            schemaType = form.schema.type;
+          }
+          else {
+            schemaType = null;
+          }
+        }
+      });
+
+
+
       scope.schemaError = function() {
         return error;
       };

src/services/unselect.js

@@ -0,0 +1,83 @@
+
+angular.module('schemaForm').factory('sfUnselect', ['sfPath', function(sfPath) {
+  var numRe = /^\d+$/;
+
+  /**
+   * @description
+   * Utility method to clear deep properties without
+   * throwing errors when things are not defined.
+   * DOES NOT create objects when they are missing.
+   *
+   * Based on sfSelect.
+   *
+   * ex.
+   * var foo = Unselect('address.contact.name',obj, null)
+   * var bar = Unselect('address.contact.name',obj, undefined)
+   * Unselect('address.contact.name',obj,'')
+   *
+   * @param {string} projection A dot path to the property you want to set
+   * @param {object} obj   (optional) The object to project on, defaults to 'this'
+   * @param {Any}    unselectValue   The value to set; if parts of the path of
+   *                 the projection is missing empty objects will NOT be created.
+   * @returns {Any|undefined} returns the value at the end of the projection path
+   *                          or undefined if there is none.
+   */
+  return function(projection, obj, unselectValue) {
+    if (!obj) {
+      obj = this;
+    }
+    //Support [] array syntax
+    var parts = typeof projection === 'string' ? sfPath.parse(projection) : projection;
+    //console.log(parts);
+
+    if (parts.length === 1) {
+      //Special case, just setting one variable
+
+      //console.log('Only 1 variable in parts');
+      obj[parts[0]] = unselectValue;
+      return obj;
+    }
+
+    if (typeof obj[parts[0]] === 'undefined') {
+      // If top-level part isn't defined.
+      var isArray = numRe.test(parts[1]);
+      if (isArray) {
+        //console.info('Expected array as top-level part, but is already undefined. Returning.');
+        return undefined;
+      }
+      else if (parts.length > 2) {
+        obj[parts[0]] = {};
+      }
+    }
+
+    var value = obj[parts[0]];
+    for (var i = 1; i < parts.length; i++) {
+      // Special case: We allow JSON Form syntax for arrays using empty brackets
+      // These will of course not work here so we exit if they are found.
+      if (parts[i] === '') {
+        return undefined;
+      }
+
+      var tmp = value[parts[i]];
+      if (i === parts.length - 1 ) {
+        //End of projection; setting the value
+
+        //console.log('Value set using destroyStrategy.');
+        value[parts[i]] = unselectValue;
+        return unselectValue;
+      } else {
+        // Make sure to NOT create new objects on the way if they are not there.
+        // We need to look ahead to check if array is appropriate.
+        // Believe that if an array/object isn't present/defined, we can return.
+
+        //console.log('Processing part %s', parts[i]);
+        if (typeof tmp === 'undefined' || tmp === null) {
+          //console.log('Part is undefined; returning.');
+          return undefined;
+        }
+        value = tmp;
+      }
+    }
+    return value;
+  };
+}]);