Eu tenho um grande hash com matrizes e hashes aninhados. Gostaria simplesmente de imprimi-lo para que fique 'legível' para o usuário.

Eu gostaria que fosse algo como to_yaml - isso é bem legível - mas ainda parece muito tecnológico.

Por fim, serão os usuários finais que precisam ler esses blocos de dados para que sejam formatados de maneira limpa.

Alguma sugestão?

require 'pp'
pp my_hash

Use ppse você precisar de uma solução integrada e apenas desejar quebras de linha razoáveis.

Use awesome_print se você pode instalar uma jóia. (Dependendo dos usuários, convém usar a index:falseopção para desativar a exibição dos índices da matriz.)

Se você possui JSON, eu recomendo, JSON.pretty_generate(hash)porque é mais simples que awesome_print , fica ótimo em uma pretag e facilita a cópia de uma página da web. (Veja também: Como posso "formatar" minha saída JSON em Ruby on Rails? )

Outra solução que funciona melhor para mim do que ppou awesome_print:

require 'pry' # must install the gem... but you ALWAYS want pry installed anyways
Pry::ColorPrinter.pp(obj)

Se você não possui nenhuma ação sofisticada de gemas, mas possui JSON, esta linha de CLI funcionará em um hash:

puts JSON.pretty_generate(my_hash).gsub(":", " =>")

#=>
{
  :key1 => "value1",

  :key2 => "value2",

  :key3 => "value3"
}

Use as respostas acima se estiver imprimindo para os usuários.

Se você quiser imprimi-lo apenas no console, sugiro usar a alavanca de alavanca em vez do irb. Além da impressão bonita, o alavanca também possui muitos outros recursos (confira o railscast abaixo)

instalar alavanca

E verifique este railscast:

http://railscasts.com/episodes/280-pry-with-rails

Fácil de fazer com o json, se você confiar que suas chaves são saudáveis:

JSON.pretty_generate(a: 1, 2 => 3, 3 => nil).
  gsub(": null", ": nil").
  gsub(/(^\s*)"([a-zA-Z][a-zA-Z\d_]*)":/, "\\1\\2:"). # "foo": 1 -> foo: 1
  gsub(/(^\s*)(".*?"):/, "\\1\\2 =>") # "123": 1 -> "123" => 1

{
  a: 1,
  "2" => 3,
  "3" => nil
}

Usando o Pry, você só precisa adicionar o seguinte código ao seu ~ / .pryrc:

require "awesome_print"
AwesomePrint.pry!

De todas as gemas que tentei, a show_datagem funcionou melhor para mim, agora a uso extensivamente para registrar hashes de params no Rails praticamente o tempo todo

Para hashes aninhados grandes, esse script pode ser útil para você. Ele imprime um hash aninhado em uma boa sintaxe semelhante a python, com apenas recuos para facilitar a cópia.

module PrettyHash
  # Usage: PrettyHash.call(nested_hash)
  # Prints the nested hash in the easy to look on format
  # Returns the amount of all values in the nested hash

  def self.call(hash, level: 0, indent: 2)
    unique_values_count = 0
    hash.each do |k, v|
      (level * indent).times { print ' ' }
      print "#{k}:"
      if v.is_a?(Hash)
        puts
        unique_values_count += call(v, level: level + 1, indent: indent)
      else
        puts " #{v}"
        unique_values_count += 1
      end
    end
    unique_values_count
  end
end

Exemplo de uso:

  h = {a: { b: { c: :d }, e: :f }, g: :i }
  PrettyHash.call(h)

a:
  b:
    c: d
  e: f
g: i
=> 3

O valor retornado é a contagem (3) de todos os valores de nível final do hash aninhado.

Aqui está outra abordagem usando json e rouge:

require 'json'
require 'rouge'

formatter = Rouge::Formatters::Terminal256.new
json_lexer = Rouge::Lexers::JSON.new

puts formatter.format(json_lexer.lex(JSON.pretty_generate(JSON.parse(response))))

(analisa a resposta de, por exemplo RestClient)

No Rails

Se você precisar

• um Hash "bem impresso"
• por exemplo, no Rails.logger
• que, especificamente, roda inspect nos objetos no Hash
  • o que é útil se você substituir / definir o inspectmétodo em seus objetos como deveria

... então isso funciona muito bem! (E fica melhor, quanto maior e mais aninhado for o objeto Hash.)

logger.error my_hash.pretty_inspect

Por exemplo:

class MyObject1
  def inspect
    "<#{'*' * 10} My Object 1 #{'*' * 10}>"
  end
end

class MyObject2
  def inspect
    "<#{'*' * 10} My Object 2 #{'*' * 10}>"
  end
end

my_hash = { a: 1, b: MyObject1.new, MyObject2.new => 3 }

Rails.logger.error my_hash
# {:a=>1, :b=><********** My Object 1 **********>, <********** My Object 2 **********>=>3}

# EW! ^

Rails.logger.error my_hash.pretty_inspect
# {:a=>1,
#  :b=><********** My Object 1 **********>,
#  <********** My Object 2 **********>=>3}

pretty_inspectvem do PrettyPrint , que os trilhos incluem por padrão. Portanto, não há necessidade de gemas nem conversão para JSON.

Não nos trilhos

Se você não está no Rails ou se o acima falhar por algum motivo, tente usar require "pp"primeiro. Por exemplo:

require "pp"  # <-----------

class MyObject1
  def inspect
    "<#{'*' * 10} My Object 1 #{'*' * 10}>"
  end
end

class MyObject2
  def inspect
    "<#{'*' * 10} My Object 2 #{'*' * 10}>"
  end
end

my_hash = { a: 1, b: MyObject1.new, MyObject2.new => 3 }

puts my_hash
# {:a=>1, :b=><********** My Object 1 **********>, <********** My Object 2 **********>=>3}

# EW! ^

puts my_hash.pretty_inspect
# {:a=>1,
#  :b=><********** My Object 1 **********>,
#  <********** My Object 2 **********>=>3}

Um exemplo completo

Big ol' pretty_inspected exemplo Hash do meu projeto com o texto específico do projeto de meus objetos inspecionados editados:

{<***::******************[**:****, ************************:****]********* * ****** ******************** **** :: *********** - *** ******* *********>=>
  {:errors=>
    ["************ ************ ********** ***** ****** ******** ***** ****** ******** **** ********** **** ***** ***** ******* ******",
     "************ ************ ********** ***** ****** ******** ***** ****** ******** **** ********** is invalid",
     "************ ************ ********** ***** ****** ******** is invalid",
     "************ ************ ********** is invalid",
     "************ ************ is invalid",
     "************ is invalid"],
   :************=>
    [{<***::**********[**:****, *************:**, ******************:*, ***********************:****] :: **** **** ****>=>
       {:************=>
         [{<***::***********[**:*****, *************:****, *******************:**]******* :: *** - ******* ***** - *>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: *** - *>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: ********* - *>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: ********** - ********** *>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: ******** - *>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: **** - *******>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: *** - ********** ***** - *>=>
            {}}]}},
     {<***::**********[**:****, *************:**, ******************:*, ***********************:****] ******************** :: *** - *****>=>
       {:errors=>
         ["************ ********** ***** ****** ******** ***** ****** ******** **** ********** **** ***** ***** ******* ******",
          "************ ********** ***** ****** ******** ***** ****** ******** **** ********** is invalid",
          "************ ********** ***** ****** ******** is invalid",
          "************ ********** is invalid",
          "************ is invalid"],
        :************=>
         [{<***::***********[**:*****, *************:****, *******************:***]******* :: ****** - ** - ********>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:***]******* :: ****** - ** - ********>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: ****** - ** - *******>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]*********** :: ****>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: ****** - ** - *******>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: ****** - ** - *********>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: ****** - ** - *******>=>
            {:errors=>
              ["********** ***** ****** ******** ***** ****** ******** **** ********** **** ***** ***** ******* ******",
               "********** ***** ****** ******** ***** ****** ******** **** ********** is invalid",
               "********** ***** ****** ******** is invalid",
               "********** is invalid"],
             :**********************=>
              [{<***::*******************[**:******, ************************:***]****-************ ******************** ***: * :: *** - ***** * ****** ** - ******* * **: *******>=>
                 {:errors=>
                   ["***** ****** ******** **** ********** **** ***** ***** ******* ******",
                    "***** ****** ******** **** ********** is invalid"],
                  :***************=>
                   [{<***::********************************[**:******, *************:******, ***********:******, ***********:"************ ************"]** * *** * ****-******* * ******** * ********* ******************** *********************: ***** :: "**** *" -> "">=>
                      {:errors=>["**** ***** ***** ******* ******"],
                       :**********=>
                        {<***::*****************[**:******, ****************:["****** ***", "****** ***", "****** ****", "******* ***", "******* ****", "******* ***", "****"], **:""] :: "**** *" -> "">=>
                          {:errors=>
                            ["***** ******* ******",
                             "***** ******* ******"]}}}}]}}]}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: ****** - ** - *********>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:**]******* :: ****** - ** - *********>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:***]******* :: ****** - ** - ********>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:***]******* :: ****** - ** - **********>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:***]******* :: ****** - ** - **********>=>
            {}},
          {<***::***********[**:*****, *************:****, *******************:***]******* :: ****** - ** - **********>=>
            {}}]}}]}}

Em Rails, matrizes e hashes no Ruby possuem funções to_json internas. Eu usaria JSON apenas porque é muito legível em um navegador da web, por exemplo, Google Chrome.

Dito isto, se você está preocupado com a aparência muito "tecnológica", provavelmente deve escrever sua própria função que substitui os chavetas e chavetas nos seus hashes e matrizes por espaços em branco e outros caracteres.

Procure a função gsub para uma maneira muito boa de fazer isso. Continue brincando com diferentes personagens e diferentes quantidades de espaço em branco até encontrar algo que pareça atraente. http://ruby-doc.org/core-1.9.3/String.html#method-i-gsub