如何在哈希参数中重命名符号？

Question

I have parameters from an external API that formats JSON responses using CamelCase that I want to fit into my Rails app:

{"AccountID"=>"REAWLLY_LONG_HASH_API_KEY_FROM_EXTERNAL_SERVICE", 
"ChannelProductDescription"=>"0004", "Currency"=>"CAD", 
"CurrentBalance"=> {"Amount"=>"162563.64", "Currency"=>"CAD"}}

Using the below script I converted them to lower case:

data = JSON.parse(response, symbolize_keys: true)
data = {:_json => data} unless data.is_a?(Hash)
data.deep_transform_keys!(&:underscore)
data.deep_symbolize_keys!

Leaving me correctly formatted params like this:

{:account_id=>"REAWLLY_LONG_HASH_API_KEY_FROM_EXTERNAL_SERVICE", 
:channel_product_description=>"SAVINGS", :currency=>"CAD", 
:current_balance=> {:amount=>"43.00", :currency=>"CAD"}}

I'm trying to map this external API response into a generic Rails model Account , where JSON from this API call will return cleanly as parameters into my database to allow a clean saving interface such as:

@account = Account.create(ParamParser.call(params))

But I ran into a problem with converting :account_id , as that param conflicts with the primary key of my database.

To get around this, my idea is to convert all symbol instances of params[:account_id] into params[:account_key_id] , so that those params don't conflict with my databases existing account_id field.

How do I do this, and is there a better approach for consuming external JSON API's than what I've described here?

Answer 1

Hash#deep_transform_keys does this:

Returns a new hash with all keys converted by the block operation. This includes the keys from the root hash and from all nested hashes and arrays.

So you could do it in one pass with an appropriate block, something like:

data.deep_transform_keys! do |key|
  key = key.underscore.to_sym
  key = :account_key_id if(key == :account_id)
  key
end

You might as well drop the symbolize_keys: true flag to JSON.parse too, you're changing all the keys anyway so don't bother.

If you're doing this sort of thing a lot then you could write a method that takes a key mapping Hash and gives you a lambda for transforming the keys:

def key_mangler(key_map = { })
  ->(key) do
    key = key.underscore.to_sym
    key = key_map[key] if(key_map.has_key?(key))
    key
  end
end

and then say things like:

data.deep_transform_keys!(&key_mangler(:account_id => :account_key_id))

You might want to use a different name than key_mangler of course but that name is good enough to illustrate the idea.

---

BTW, if you're sending this JSON into the database then you probably don't need to bother with symbol keys, JSON only uses strings for keys so you'll be converting strings to symbols only for them to be converted back to strings. Of course, if you're symbolizing the keys when pulling the JSON out of the database then you'll probably want to be consistent and use symbols across the board.

Answer 2

In addition to the previous answer...

Unfortunately, there is, to my knowledge, no method on Hash that does this in one operation. I've always accomplished this by brute force, as in:

hash[:new_key] = hash[:old_key]
hash.delete(:old_key)

A shortcut for this, suggested in the comment below by "mu is too short", is:

hash[:new_key] = hash.delete(:old_key)

To illustrate in irb:

2.4.1 :002 > h = { foo: :bar }
 => {:foo=>:bar}
2.4.1 :003 > h[:foo_new] = h.delete(:foo)
 => :bar
2.4.1 :004 > h
 => {:foo_new=>:bar}