Jak sortować pliki YAML?

Question

Próbowałem posortować plik YAML tłumaczący i18n z Ruby, dzięki czemu mogę zarządzać nowymi tłumaczeniami w lepszy i zorganizowany sposób, ale zastanawiałem się, czy jest coś, co ułatwi zadanie.

Znalazłem pisarz pliku YAML, więc mogę napisać hasz do pliku, ale moim problemem jest prawidłowe sortowanie hasza. Jeśli mam hash h, h.sort zwraca tablicę i nadal nie wymyśliłem prosty sposób to zrobić.

mam pliki YAML tak:

pt-br:  
    global: 
    misc: 
     total: "Total" 
     all: "Todos" 
     close: "Fechar" 
     cancel: "Cancelar" 

    crud: 
     access: "Acessar" 
     back: "Voltar" 
     edit: "Editar" 
     confirm: "Confirmar" 
     send: "Enviar" 

... 

(Pliki są zdecydowanie większe niż to)

Ale chcę sortować je w ten sposób:

pt-br:  
    global: 
    crud: 
     access: "Acessar" 
     back: "Voltar" 
     confirm: "Confirmar" 
     edit: "Editar" 
     send: "Enviar" 

    misc: 
     all: "Todos" 
     cancel: "Cancelar" 
     close: "Fechar"   
     total: "Total" 

myślałem, że niektóre proste metody rekurencyjne mogą mi pomóc:

def translation_sort(h) 
    if h.class == Hash 
    h = h.sort 
    h.each{|item| translation_sort(item)} 
    end 
    h 
end 

require "yaml" 
h=YAML.load_file(File.open("~/pt-br.sample.yml")) 
translation_sort(h) 

Answer 1

Właściwie to miłe pytanie. Chcesz dogłębnie sortować hasze. Więc nie lubię ponownie wymyślać koła, a potem szukałem dobrej implementacji i znalazłem taką, którą lubię. Spójrz na to https://gist.github.com/1083930. To działa dobrze.

Answer 2

W hasłach Ruby 1.8 nie ma określonego zamówienia, więc nie można ich sortować.

Mogłabyś monkey-patch/nadpisać metodę to_yaml z Hash takiego:

#!/usr/local/bin/ruby -w 

require 'yaml' 

class Hash 
    def to_yaml(opts = {}) 
    YAML::quick_emit(self, opts) do |out| 
     out.map(taguri, to_yaml_style) do |map| 
     keys.sort.each do |k| 
      v = self[k] 
      map.add(k, v) 
     end 
     end 
    end 
    end 
end 

dict = YAML.load($<.read) 

puts dict.to_yaml 

Oczywiście, dokładne szczegóły mogą zależeć od wersji YAML/Ruby. Powyższy przykład dotyczy Ruby 1.8.6.

Answer 3

Oto kolejna alternatywa dla każdego, kto jest po drugiej stronie tego ..

require 'yaml' 

yaml = YAML.load(IO.read(File.join(File.dirname(__FILE__), 'example.yml'))) 

@yml_string = "---\n" 

def recursive_hash_to_yml_string(hash, depth=0) 
    spacer = "" 
    depth.times { spacer += " "} 
    hash.keys.sort.each do |sorted_key| 
    @yml_string += spacer + sorted_key + ": " 
    if hash[sorted_key].is_a?(Hash) 
     @yml_string += "\n" 
     recursive_hash_to_yml_string(hash[sorted_key], depth+1) 
    else 
     @yml_string += "#{hash[sorted_key].to_s}\n" 
    end 
    end 
end 

recursive_hash_to_yml_string(yaml) 

open(File.join(File.dirname(__FILE__), 'example.yml'), 'w') { |f| 
    f.write @yml_string 
} 

Answer 4

Nie należy korzystać z biblioteki YAML jak sugerowano w innych odpowiedzi. Zmniejszy to formatowanie długich wartości ciągu, usunie komentarze i wypisze nieczytelne znaki, gdy użyjesz akcentów i znaków specjalnych (co zrobisz, ponieważ robisz i18n). Użyj tego gem stworzyłem:

https://github.com/redealumni/i18n_yaml_sorter

To będzie tylko sortować wiersze w pliku, więc wszystko pozostanie tak samo było na oryginalnym YAML (swoich akcentów i YAML skonstruować użyłeś aby wejść struny, wcięcia, itp.). Będzie działać z głęboko zagnieżdżonymi yamlami, a wyniki są całkiem solidne. Klejnot zawiera testy i jest dobry dla ruby ​​1.8 lub 1.9.

Jest dostarczany z pakietem TextMate (Shift + Command + S) i zadaniem prowizji Rails, dzięki czemu możesz sortować pliki łatwo i szybko w edytorze. Jest naprawdę szybki.

Aby zilustrować różnicę:

oryginalny:

pt-BR: 
    # Note how this is a nice way of inputing 
    # paragraphs of text in YAML. 
    apples: > 
     Maçãs são boas, 
     só não coma 
     seus iPods! 
    grapes: Não comemos elas. 
    bananas: | 
     Bananas são "legais": 
     - Elas são <b> doces </b>. 
     isto: não é chave 

     Por isto todos gostam de bananas! 

wyniki Według YAML :: dump:

pt-BR: 
    apples: "Ma\xC3\xA7\xC3\xA3s s\xC3\xA3o boas, s\xC3\xB3 n\xC3\xA3o coma seus iPods!\n" 
    bananas: "Bananas s\xC3\xA3o \"legais\":\n - Elas s\xC3\xA3o <b> doces </b>.\n isto: n\xC3\xA3o \xC3\xA9 chave\n\n\ Por isto todos gostam de bananas!\n" 
    grapes: "N\xC3\xA3o comemos elas." 

wyniki Według i18n_yaml_sorter:

pt-BR: 
    # Note how this is a nice way of inputing 
    # paragraphs of text in YAML. 
    apples: > 
     Maçãs são boas, 
     só não coma 
     seus iPods! 
    bananas: | 
     Bananas são "legais": 
     - Elas são <b> doces </b>. 
     isto: não é chave 

     Por isto todos gostam de bananas! 
    grapes: Não comemos elas. 

Answer 5

https://gist.github.com/1083930 nie działa zgodnie z oczekiwaniami. Głęboko sortuje NIE TYLKO klawisze skrótu, ALE RÓWNIEŻ wartości mieszania. W moich przypadkach użycia, w których konieczne jest głębokie sortowanie hasza, skrótem jest zawsze drzewo, w którym kluczami są etykiety, a wartości to (pod) drzewa (jeśli są hashami) lub liście (w przeciwnym razie). Potrzebuję dokładnego sortowania tylko etykiet drzew.

Mam ten

before: {"a":[2,10,{"5":null,"1":null,"3":null}],"x":{"5":null,"1":null,"3":null},"a2":{"5":[2,10,5],"1":null,"3":null}} 
after: {"a":[2,10,{"5":null,"1":null,"3":null}],"a2":{"1":null,"3":null,"5":[2,10,5]},"x":{"1":null,"3":null,"5":null}} 

z tym

require 'active_support' 

def deeply_sort_hash(object) 
    return object unless object.is_a?(Hash) 
    hash = RUBY_VERSION >= '1.9' ? Hash.new : ActiveSupport::OrderedHash.new 
    object.each { |k, v| hash[k] = deeply_sort_hash(v) } 
    sorted = hash.sort { |a, b| a[0].to_s <=> b[0].to_s } 
    hash.class[sorted] 
end 

Answer 6

Może to być kolejna atrakcyjna opcja: https://github.com/redealumni/i18n_yaml_sorter

Answer 7

UPDATE kwietnia 2014:

Korzystanie szyn 3 .2.13 , Ruby 1.9 .3p489:

Właśnie użyłem klejnoty i18n_yaml_sorter (https://github.com/redealumni/i18n_yaml_sorter).

Wystarczy dodać do swojej Gemfile:

gem 'i18n_yaml_sorter', group: :development 

Następnie uruchom zadanie natarcia uporządkować swoje pliki locale:

rake i18n:sort 

działało idealnie, choć gem ma Ostatni autor 2 lata temu. Trwało to maksymalnie 5 minut.

Answer 8

Istnieje również pakiet atom że zrobi to jak dobrze https://github.com/akfernun/yaml-sortkeys