def validate(opts, map)
      #--
      # validate works by taking the keys in the validation map, assuming it's a hash, and
      # looking for _pv_:symbol as methods.  Assuming it find them, it calls the right 
      # one.  
      #++
      raise ArgumentError, "Options must be a hash" unless opts.kind_of?(Hash)
      raise ArgumentError, "Validation Map must be a hash" unless map.kind_of?(Hash)   
      
      map.each do |key, validation|
        unless key.kind_of?(Symbol) || key.kind_of?(String)
          raise ArgumentError, "Validation map keys must be symbols or strings!"
        end
        case validation
        when true
          _pv_required(opts, key)
        when false
          true
        when Hash
          validation.each do |check, carg|
            check_method = "_pv_#{check.to_s}"
            if self.respond_to?(check_method, true)
              self.send(check_method, opts, key, carg)
            else
              raise ArgumentError, "Validation map has unknown check: #{check}"
            end
          end
        end
      end
      opts
    end
def validate(opts, map)
      #--
      # validate works by taking the keys in the validation map, assuming it's a hash, and
      # looking for _pv_:symbol as methods.  Assuming it find them, it calls the right 
      # one.  
      #++
      raise ArgumentError, "Options must be a hash" unless opts.kind_of?(Hash)
      raise ArgumentError, "Validation Map must be a hash" unless map.kind_of?(Hash)   
      
      map.each do |key, validation|
        unless key.kind_of?(Symbol) || key.kind_of?(String)
          raise ArgumentError, "Validation map keys must be symbols or strings!"
        end
        case validation
        when true
          _pv_required(opts, key)
        when false
          true
        when Hash
          validation.each do |check, carg|
            check_method = "_pv_#{check.to_s}"
            if self.respond_to?(check_method, true)
              self.send(check_method, opts, key, carg)
            else
              raise ArgumentError, "Validation map has unknown check: #{check}"
            end
          end
        end
      end
      opts
    end
Takes a hash of options, along with a map to validate them.  Returns the original
 options hash, plus any changes that might have been made (through things like setting
 default values in the validation map)

 For example:

   validate({ :one => "neat" }, { :one => { :kind_of => String }})

 Would raise an exception if the value of :one above is not a kind_of? string.  Valid
 map options are:

 :default:: Sets the default value for this parameter.
 :callbacks:: Takes a hash of Procs, which should return true if the argument is valid.
              The key will be inserted into the error message if the Proc does not return true:
                 "Option #{key}'s value #{value} #{message}!"
 :kind_of:: Ensure that the value is a kind_of?(Whatever).  If passed an array, it will ensure
            that the value is one of those types.
 :respond_to:: Ensure that the value has a given method.  Takes one method name or an array of
               method names.
 :required:: Raise an exception if this parameter is missing. Valid values are true or false,
             by default, options are not required.
 :regex:: Match the value of the paramater against a regular expression.
 :equal_to:: Match the value of the paramater with ==.  An array means it can be equal to any
             of the values.