class AWS::Core::Options::JSONSerializer

are validated before returning JSON.
a hash of request options into a JSON document. The request options
Given a hash of serialization rules, a JSONSerializer can convert

def initialize rules, payload_param

Parameters:
  • payload_param (String, nil) --
  • rules (Hash) -- A hash of option rules to validate against. 
def initialize rules, payload_param
  @payload_param = payload_param
  @rules = @payload_param ? rules[@payload_param][:members] : rules
end

def normalize_keys values, rules 

def normalize_keys values, rules
  values.inject({}) do |h,(k,v)|
    child_rules = rules[k]
    child_name = child_rules[:name] || Inflection.class_name(k.to_s)
    h.merge(child_name => normalize_value(v, child_rules))
  end
end

def normalize_value value, rules 

def normalize_value value, rules
  case rules[:type]
  when :hash then normalize_keys(value, rules[:members])
  when :array then value.map{|v| normalize_value(v, rules[:members]) }
  when :map
    value.inject({}) do |h,(k,v)|
      h.merge(k => normalize_value(v, rules[:members]))
    end
  when :blob then Base64.encode64(value.read).strip
  else value
  end
end

def serialize request_options

Returns:
  • (String) - Returns an string of the request parameters

Parameters:
  • request_options (Hash) -- A hash of already validated

Overloads:
  • serialize!(request_options) 
def serialize request_options
  request_options = request_options[@payload_param] if @payload_param
  data = normalize_keys(request_options, rules)
  if rules.any?{|k,v| v[:location] == 'body' }
    data = data.values.first
  end
  JSON.pretty_generate(data)
end