docs: def __execute_validations(self, validations, data, property_name, ancestors, negation=False, prefix=None):
          """ Validate the data for a specific configuration value. This method will look up all of the validations provided
          and dynamically call any validation methods. If a validation fails a error will be thrown.  If no errors are found
          a attributes will be dynamically created on the Config object for the configuration value.
  
          :param validations: A :dict: with any required validations and expected values.
          :param data: the data to validate.
          :param property_name: A :string:, the properties name.
          :param ancestors: A :OrderedDict:, representing the ancestors of a property.
          """
          if not isinstance(ancestors, OrderedDict):
              raise TypeError("ancestors must be an OrderedDict. type: {0} was passed.".format(type(ancestors)))
  
          if not isinstance(validations, dict):
              raise TypeError('validations is required to be a dict. type: {1} was passed.'.format(type(validations)))
  
          if not isinstance(property_name, six.string_types):
              raise TypeError("property_key must be a string. type: {0} was passed.".format(type(property_name)))
  
          # reorder validates putting required first.  If the data doesn't exist there is no need to continue.
          order = ['type', 'required'] + [key for key in validations.keys() if key not in ('required', 'type')]
          ordered_validations = OrderedDict(sorted(validations.items(), key=lambda x: order.index(x[0])))
  
          for validation, value in six.iteritems(ordered_validations):
              if validation in VALIDATORS:
  
                  if validation == 'not':
                      # TODO: need to test to make sure this works
                      for err in self.__execute_validations(value, data, property_name, ancestors, negation, prefix):
                          yield err
  
                      continue
  
                  for err in getattr(self, '_{0}'.format(validation))(value, data, property_name, ancestors, negation, prefix):
                      yield err
  
              else:
                  raise LookupError("{0} isn't a validator or reserved scheme key.".format(validation))