Convertir des .json pour .csv en ruby

Essayer quelque chose comme cela:

require 'csv'
require 'json'

csv_string = CSV.generate do |csv|
  JSON.parse(File.open("foo.json").read).each do |hash|
    csv << hash.values
  end
end

puts csv_string

Je pense que le easies moyen de convertir le JSON, CSV en ruby, c'est à l'aide de json2csv ruby gem.

PS: je suis peut-être biaisé comme je suis l'auteur de ce.

json2csv dépôt github

L'exécution de la commande

json2csv convert data/sample.json

Fichier D'Entrée

Dans ce cas particulier, il va les convertir en json suivants:

cat data/sample.json

{
"12345": {
    "Firstname": "Joe",
    "Lastname": "Doe",
    "Address": {
        "Street": "#2140 Taylor Street, 94133",
        "City": "San Francisco",
        "Details": {
            "note": "Pool available"
        }
    }
},

"45678": {
    "Firstname": "Jack",
    "Lastname": "Plumber",
    "Address": {
        "Street": "#111 Sutter St, 94104",
        "City": "San Francisco",
        "Details": {
            "note": "Korean Deli near to main entrance"
        }
    }
}

Sortie

cat data/sample.json.csv

id,Firstname,Lastname,Address.Street,Address.City,Address.Details.note
12345,Joe,Doe,"#2140 Taylor Street, 94133",San Francisco,Pool available
45678,Jack,Plumber,"#111 Sutter St, 94104",San Francisco,Korean Deli near to main entrance

Edit:

Cette fonctionnalité décrite ci-dessous est maintenant disponible comme une gem. Après l'installation avec gem install json_converter, le fragment de code suivant peut être utilisé pour générer un fichier CSV à partir d'une chaîne JSON valide ou d'un objet:

require 'json_converter'
json_converter= JsonConverter.new

# Assume json is a valid JSON string or object
csv = json_converter.generate_csv json

Réponse Originale À Cette Question:

Si vos données JSON est relativement simple (pas d'imbrication ou de tableaux), Alex réponse est probablement la façon la plus propre de la gestion de ce problème.

Toutefois, si vous ne besoin de prendre des tableaux et des objets imbriqués en compte, j'ai tenté de port un version web d'un tel convertisseur de ruby. Il peut être trouvé ici. Les méthodes pour gérer la réelle restructuration de données sont array_from et flatten.

La array_from méthode tente d'identifier ce qu'est une "ligne" de données ressemble à un jeu de données. Il n'est pas parfait, et vous pouvez ajuster cette partie pour les différents ensembles de données.

# Attempt to identify what a "row" should look like
def array_from(json)
  queue, next_item = [], json
  while !next_item.nil?

    return next_item if next_item.is_a? Array

    if next_item.is_a? Hash
      next_item.each do |k, v|
        queue.push next_item[k]
      end
    end

    next_item = queue.shift
  end

  return [json]
end

La flatten méthode récursive itère sur l'objet JSON(s), et génère un objet qui représente les en-têtes et des valeurs. Si un objet est imbriqué, l'en-tête de sa colonne seront préfixés avec sa clé parent(s), délimité par le / caractère.

# The path argument is used to construct header columns for nested elements
def flatten(object, path='')
  scalars = [String, Integer, Fixnum, FalseClass, TrueClass]
  columns = {}

  if [Hash, Array].include? object.class
    object.each do |k, v|
      new_columns = flatten(v, "#{path}#{k}/") if object.class == Hash
      new_columns = flatten(k, "#{path}#{k}/") if object.class == Array
      columns = columns.merge new_columns
    end

    return columns
  elsif scalars.include? object.class
      # Remove trailing slash from path
      end_path = path[0, path.length - 1]
      columns[end_path] = object
      return columns
  else
    return {}
  end
end

S'il y a des null valeurs à l'origine, JSON, vous aurez besoin de les transformer en quelque chose d'autre que nil avant de tenter la conversion, vous aurez généralement à la fin avec l'inégale des lignes si vous n'avez pas. Le nils_to_strings méthode de poignées:

# Recursively convert all nil values of a hash to empty strings
def nils_to_strings(hash)
  hash.each_with_object({}) do |(k,v), object|
    case v
    when Hash
      object[k] = nils_to_strings v
    when nil
      object[k] = ''
    else
      object[k] = v
    end
  end
end

Voici un bref exemple de la façon dont ce serait utilisée:

json = JSON.parse(File.open('in.json').read)
in_array = array_from json
in_array.map! { |x| nils_to_strings x }

out_array = []
in_array.each do |row|
  out_array[out_array.length] = flatten row
end

headers_written = false
CSV.open('out.csv', 'w') do |csv|
  out_array.each do |row|
    csv << row.keys && headers_written = true if headers_written === false
    csv << row.values
  end
end

Et enfin, voici un exemple d'entrée/sortie:

D'entrée:

{
"Forms": [
{
"Form": {
"id": "x",
"version_id": "x",
"name": "x",
"category": "",
"subcategory": null,
"is_template": null,
"moderation_status": "x",
"display_status": "x",
"use_ssl": "x",
"modified": "x",
"Aggregate_metadata": {
"id": "x",
"response_count": "x",
"submitted_count": "x",
"saved_count": "x",
"unread_count": "x",
"dropout_rate": "x",
"average_completion_time": null,
"is_uptodate": "x"
}
},
"User": {
"username": "[email protected]"
}
},
{
"Form": {
"id": "x",
"version_id": "x",
"name": "x",
"category": "",
"subcategory": null,
"is_template": null,
"moderation_status": "x",
"display_status": "x",
"use_ssl": "x",
"modified": "x",
"Aggregate_metadata": {
"id": "x",
"response_count": "x",
"submitted_count": "x",
"saved_count": "x",
"unread_count": "x",
"dropout_rate": "x",
"average_completion_time": null,
"is_uptodate": "x"
}
},
"User": {
"username": "[email protected]"
}
}
]
}

De sortie:

Form/id,Form/version_id,Form/name,Form/category,Form/subcategory,Form/is_template,Form/moderation_status,Form/display_status,Form/use_ssl,Form/modified,Form/Aggregate_metadata/id,Form/Aggregate_metadata/response_count,Form/Aggregate_metadata/submitted_count,Form/Aggregate_metadata/saved_count,Form/Aggregate_metadata/unread_count,Form/Aggregate_metadata/dropout_rate,Form/Aggregate_metadata/average_completion_time,Form/Aggregate_metadata/is_uptodate,User/username
x,x,x,"","","",x,x,x,x,x,x,x,x,x,x,"",x,somedude@example.com
x,x,x,"","","",x,x,x,x,x,x,x,x,x,x,"",x,somedude@example.com

C'est gérer les en-têtes & imbriqués json.

require 'csv'
require 'json'
@headers = []
file = File.open('file.json')
JSON.parse(file.read).each do |h|
h.keys.each do |key|
@headers << key
end
end
uniq_headers = @headers.uniq
file = File.open('file.json')
finalrow = []
JSON.parse(file.read).each do |h|
final = {}
@headers.each do |key2|
final[key2] = h[key2]
end
finalrow << final
end
CSV.open('output.csv' , 'w') do |csv|
csv << uniq_headers
finalrow.each do |deal|
csv << deal.values
end
end