Headless Rails, easy way to store a hash? - ruby-on-rails

Question

I'm new to rails, but most of the documentation is towards user inputting something into the view and it eventually gets passed into the database.
Is there a rails way of storing below into a SQL database? Do I put it in the model or controller?
Is there a clean way to store this data, or do I have to explicitly store every attribute in this Hash individually?
I've already made the migrations manually that matches most if not all of the hashed data below, but is there a tool that can convert these hashes into a relational Data model?
.
{
"_id" : "36483f88e04d6dcb60684a33000791a6bc522a41",
"address_components" : [
{
"long_name" : "ON",
"short_name" : "ON",
"types" : [
"administrative_area_level_1",
"political"
]
},
{
"long_name" : "CA",
"short_name" : "CA",
"types" : [
"country",
"political"
]
},
{
"long_name" : "M5J 1L4",
"short_name" : "M5J 1L4",
"types" : [
"postal_code"
]
}
],
"formatted_address" : "ON, Canada",
"formatted_phone_number" : "[phone]",
"geometry" : {
"location" : {
"lat" : 43.640816,
"lng" : -79.381752
}
},
"icon" : "http://maps.gstatic.com/mapfiles/place_api/icons/restaurant-71.png",
"id" : "36483f88e04d6dcb60684a33000791a6bc522a41",
"international_phone_number" : "[phone]",
"name" : "Scandinavian Airlines",
"reference" : "CoQBcgAAAMobbidhAbzwIMkxq3GTHzzlEW4hAAwxg5EmGDP7ZOcJRwUK29poFMTDvED5KW9UEQrqtgTwESj_DuCAchy6Qe5pPZH9tB47MmmuQHvyHFlApunmU3MN05_KLekN5hEbrW7Gv2ys2oXmn7FpvD7-0N0QILlFXCiwL5UlYWo2sEg3EhBMBsrkHBu4WCFsMCHRqgadGhTM3BVWR15l9L87zL1uN1ssoW4WCw",
"types" : [
"restaurant",
"food",
"establishment"
],
"url" : "https://plus.google.com/100786723768255083253/about?hl=en-US",
"utc_offset" : -300,
"vicinity" : ""
}

Answer 1

This data structure can be stored by a matching hierarchy of models/associations.
There is a very clean way which is...
Use accepts_nested_attributes_for. This will work for your entire structure except for the 'types' arrays which contains simple lists of strings. However, you can use a workaround for this specific case.
The only thing that cannot be stored (easily) is the id. ActiveRecord won't permit you to set the id directly, as it is supposed to be an implementation detail of the backing database. In your case, you can simply borrow the _id field which seems to contain the same data and insert that into an alias of some sort.
Here is an example of the code you might use:
class Address < ActiveRecord::Base
has_many :address_components
has_many :address_types
has_one :geometry
attr_accessor :address_components_attributes, :geometry_attributes
accepts_nested_attributes_for :address_components, :geometry
def types=(types)
types.each do |t|
self.address_types << AddressType.build(name: t)
end
end
def _id=(orig_id)
self.original_id = orig_id
end
end
class AddressType < ActiveRecord::Base
belongs_to :address
end
class Geometry < ActiveRecord::Base
belongs_to :address
has_one :location
attr_accessor :location_attributes
accepts_nested_attributes_for :location
end
class Location < ActiveRecord::Base
belongs_to :geometry
end
class AddressComponent < ActiveRecord::Base
belongs_to :address
has_many :component_types
def types=(types)
types.each do |t|
self.component_types << ComponentType.build(name: t)
end
end
end
class ComponentType < ActiveRecord::Base
belongs_to :address_component
end
Now you can store the entire structure using:
Address.create(data_hash)

Answer 2

If you have setter methods on your model, they can handle the data and import from this hash as you would want.
For example, given the hash above, if you had a method:
def address_components=(ac)
# Handle address components
end
This will get called if when you do the following (assuming the name of your model is MyModel and the hash is stored in #hash).
MyModel.new(#hash)
All the keys will trigger setter methods of the structure 'key='. This is very powerful - if you have a very well structured model, but have an arbitrary hash, you can create methods that handle the keys in the hash. Based on these, you can build new objects, build associations and save it all at the same time.
Note - you may need to strip out some keys, or handle some keys that use reserved ruby terms in a custom way.