¿Cómo eliminar recursivamente todas las claves con valores vacíos de hash (YAML)?

Question

que han estado tratando de deshacerse de todas las claves hash en mi archivo YAML que tienen valores vacíos (en blanco) o hashes vacías como valores.

Este earlier post me ayudó a hacerlo bien, pero el recursivo de una línea sale de mi volcado de YAML con hashes vacíos cada vez que hay una anidación suficientemente profunda.

Realmente agradecería cualquier ayuda en esto. ¡Gracias!

proc = Proc.new { |k, v| (v.kind_of?(Hash) && !v.empty?) ? (v.delete_if(&proc); nil) : v.blank? } 

hash = {"x"=>{"m"=>{"n"=>{}}}, 'y' => 'content'} 
hash.delete_if(&proc) 

salida real

{"x"=>{"m"=>{}}, "y"=>"content"} 

deseado de salida

{"y"=>"content"} 

Answer 1

class Hash 
    def delete_blank 
    delete_if{|k, v| v.empty? or v.instance_of?(Hash) && v.delete_blank.empty?} 
    end 
end 

p hash.delete_blank 
# => {"y"=>"content"} 

Answer 2

hash = {"x"=>{"m"=>{"n"=>{}}}, 'y' => 'content'} 
clean = proc{ |k,v| !v.empty? ? Hash === v ? v.delete_if(&clean) : false : true } 
hash.delete_if(&clean) 
#=> {"y"=>"content"} 

o como @sawa sugiere, se puede utilizar este proc

clean = proc{ |k,v| v.empty? or Hash === v && v.delete_if(&clean) } 

Answer 3

Sólo un poco lo relacionado. Si desea borrar las claves específicas del resumen anidada:

def find_and_destroy(*keys) 
    delete_if{ |k, v| (keys.include?(k.to_s) ? true : ((v.each { |vv| vv = vv.find_and_destroy(*keys) }) if v.instance_of?(Array) ; (v.each { |vv| vv = vv.find_and_destroy(*keys) }) if v.instance_of?(Hash); false))} 
end 

.También puede personalizar aún más

Answer 4

Sé que este hilo es un poco viejo, pero se me ocurrió una mejor solución que soporta los hashes multidimensionales. Utiliza delete_if? excepto que es multidimensional y borra todo lo que tiene un valor vacío por defecto y si se pasa un bloque se pasa a través de sus hijos.

# Hash cleaner 
class Hash 
    def clean! 
     self.delete_if do |key, val| 
      if block_given? 
       yield(key,val) 
      else 
       # Prepeare the tests 
       test1 = val.nil? 
       test2 = val === 0 
       test3 = val === false 
       test4 = val.empty? if val.respond_to?('empty?') 
       test5 = val.strip.empty? if val.is_a?(String) && val.respond_to?('empty?') 

       # Were any of the tests true 
       test1 || test2 || test3 || test4 || test5 
      end 
     end 

     self.each do |key, val| 
      if self[key].is_a?(Hash) && self[key].respond_to?('clean!') 
       if block_given? 
        self[key] = self[key].clean!(&Proc.new) 
       else 
        self[key] = self[key].clean! 
       end 
      end 
     end 

     return self 
    end 
end 

Answer 5

Aquí es un método más genérico:

class Hash 
    def deep_reject(&blk) 
    self.dup.deep_reject!(&blk) 
    end 

    def deep_reject!(&blk) 
    self.each do |k, v| 
     v.deep_reject!(&blk) if v.is_a?(Hash) 
     self.delete(k) if blk.call(k, v) 
    end 
    end 
end 

{ a: 1, b: nil, c: { d: nil, e: '' } }.deep_reject! { |k, v| v.blank? } 
==> { a: 1 } 

Answer 6

Creo que esta la versión más correcta:

h = {a: {b: {c: "",}, d:1}, e:2, f: {g: {h:''}}} 
p = proc do |_, v| 
    v.delete_if(&p) if v.respond_to? :delete_if 
    v.nil? || v.respond_to?(:"empty?") && v.empty? 
end 
h.delete_if(&p) 
#=> {:a=>{:d=>1}, :e=>2}