So formatieren Sie JSON-Ausgaben in Ruby on Rails „hübsch“

Ich möchte, dass meine JSON-Ausgabe in Ruby on Rails "hübsch" oder schön formatiert ist.

Im Moment rufe ich an to_jsonund mein JSON ist alles in einer Leitung. Manchmal kann es schwierig sein, festzustellen, ob im JSON-Ausgabestream ein Problem vorliegt.

Gibt es eine Möglichkeit, mein JSON so zu konfigurieren, dass es in Rails "hübsch" oder schön formatiert ist?

Verwenden Sie die pretty_generate()in späteren Versionen von JSON integrierte Funktion. Zum Beispiel:

require 'json'
my_object = { :array => [1, 2, 3, { :sample => "hash"} ], :foo => "bar" }
puts JSON.pretty_generate(my_object)

Was bringt dich:

{
  "array": [
    1,
    2,
    3,
    {
      "sample": "hash"
    }
  ],
  "foo": "bar"
}

Dank Rack Middleware und Rails 3 können Sie für jede Anforderung hübsches JSON ausgeben, ohne den Controller Ihrer App zu ändern. Ich habe ein solches Middleware-Snippet geschrieben und bekomme JSON in Browser und curlAusgabe schön gedruckt .

class PrettyJsonResponse
  def initialize(app)
    @app = app
  end

  def call(env)
    status, headers, response = @app.call(env)
    if headers["Content-Type"] =~ /^application\/json/
      obj = JSON.parse(response.body)
      pretty_str = JSON.pretty_unparse(obj)
      response = [pretty_str]
      headers["Content-Length"] = pretty_str.bytesize.to_s
    end
    [status, headers, response]
  end
end

Der obige Code sollte in app/middleware/pretty_json_response.rbIhr Rails-Projekt eingefügt werden. Und der letzte Schritt ist die Registrierung der Middleware in config/environments/development.rb:

config.middleware.use PrettyJsonResponse

Ich empfehle nicht, es in zu verwendenproduction.rb . Das JSON-Reparsing kann die Antwortzeit und den Durchsatz Ihrer Produktions-App beeinträchtigen. Möglicherweise wird eine zusätzliche Logik wie der Header 'X-Pretty-Json: true' eingeführt, um die Formatierung für manuelle Curl-Anforderungen bei Bedarf auszulösen.

(Getestet mit Rails 3.2.8-5.0.0, Ruby 1.9.3-2.2.0, Linux)

Das <pre>mit verwendete HTML-Tag JSON.pretty_generatemacht den JSON aus Ihrer Sicht hübsch. Ich war so glücklich, als mein berühmter Chef mir Folgendes zeigte:

<% if @data.present? %>
   <pre><%= JSON.pretty_generate(@data) %></pre>
<% end %>

Wenn du möchtest:

1. Verschönern Sie alle ausgehenden JSON-Antworten von Ihrer App automatisch.
2. Vermeiden Sie es, das Objekt # to_json / # as_json zu verschmutzen
3. Vermeiden Sie das Parsen / erneute Rendern von JSON mithilfe von Middleware (YUCK!).
4. Mach es auf den RAILS WAY!

Dann ... ersetzen Sie den ActionController :: Renderer für JSON! Fügen Sie Ihrem ApplicationController einfach den folgenden Code hinzu:

ActionController::Renderers.add :json do |json, options|
  unless json.kind_of?(String)
    json = json.as_json(options) if json.respond_to?(:as_json)
    json = JSON.pretty_generate(json, options)
  end

  if options[:callback].present?
    self.content_type ||= Mime::JS
    "#{options[:callback]}(#{json})"
  else
    self.content_type ||= Mime::JSON
    json
  end
end

Schauen Sie sich Awesome Print an . Analysieren Sie die JSON-Zeichenfolge in einen Ruby-Hash und zeigen Sie sie dann folgendermaßen an ap:

require "awesome_print"
require "json"

json = '{"holy": ["nested", "json"], "batman!": {"a": 1, "b": 2}}'

ap(JSON.parse(json))

Mit den oben genannten sehen Sie:

{
  "holy" => [
    [0] "nested",
    [1] "json"
  ],
  "batman!" => {
    "a" => 1,
    "b" => 2
  }
}

Mit Awesome Print wird auch eine Farbe hinzugefügt, die Stack Overflow nicht anzeigt.

Dumping eines ActiveRecord-Objekts an JSON (in der Rails-Konsole):

pp User.first.as_json

# => {
 "id" => 1,
 "first_name" => "Polar",
 "last_name" => "Bear"
}

Verwenden von <pre>HTML-Code und pretty_generateist ein guter Trick:

<%
  require 'json'

  hash = JSON[{hey: "test", num: [{one: 1, two: 2, threes: [{three: 3, tthree: 33}]}]}.to_json] 
%>

<pre>
  <%=  JSON.pretty_generate(hash) %>
</pre>

Wenn Sie feststellen, dass die pretty_generatein Rubys JSON-Bibliothek integrierte Option nicht "hübsch" genug ist, empfehle ich mein eigenes NeatJSON- Juwel für Ihre Formatierung.

Um es zu benutzen:

gem install neatjson

und dann verwenden

JSON.neat_generate

anstatt

JSON.pretty_generate

Wie bei Ruby ppwerden Objekte und Arrays in einer Zeile gehalten, wenn sie passen, aber bei Bedarf in mehrere Zeilen umbrochen. Zum Beispiel:

{
  "navigation.createroute.poi":[
    {"text":"Lay in a course to the Hilton","params":{"poi":"Hilton"}},
    {"text":"Take me to the airport","params":{"poi":"airport"}},
    {"text":"Let's go to IHOP","params":{"poi":"IHOP"}},
    {"text":"Show me how to get to The Med","params":{"poi":"The Med"}},
    {"text":"Create a route to Arby's","params":{"poi":"Arby's"}},
    {
      "text":"Go to the Hilton by the Airport",
      "params":{"poi":"Hilton","location":"Airport"}
    },
    {
      "text":"Take me to the Fry's in Fresno",
      "params":{"poi":"Fry's","location":"Fresno"}
    }
  ],
  "navigation.eta":[
    {"text":"When will we get there?"},
    {"text":"When will I arrive?"},
    {"text":"What time will I get to the destination?"},
    {"text":"What time will I reach the destination?"},
    {"text":"What time will it be when I arrive?"}
  ]
}

Es unterstützt auch eine Vielzahl von Formatierungsoptionen , um Ihre Ausgabe weiter anzupassen. Wie viele Leerzeichen vor / nach Doppelpunkten? Vor / nach Kommas? In den Klammern von Arrays und Objekten? Möchten Sie die Schlüssel Ihres Objekts sortieren? Möchten Sie, dass alle Doppelpunkte in einer Reihe stehen?

Hier ist eine Middleware-Lösung, die von dieser hervorragenden Antwort von @gertas modifiziert wurde . Diese Lösung ist nicht Rails-spezifisch - sie sollte mit jeder Rack-Anwendung funktionieren.

Die hier verwendete Middleware-Technik unter Verwendung von #each wird in ASCIIcasts 151: Rack Middleware von Eifion Bedford erläutert .

Dieser Code befindet sich in app / middleware / pretty_json_response.rb :

class PrettyJsonResponse

  def initialize(app)
    @app = app
  end

  def call(env)
    @status, @headers, @response = @app.call(env)
    [@status, @headers, self]
  end

  def each(&block)
    @response.each do |body|
      if @headers["Content-Type"] =~ /^application\/json/
        body = pretty_print(body)
      end
      block.call(body)
    end
  end

  private

  def pretty_print(json)
    obj = JSON.parse(json)  
    JSON.pretty_unparse(obj)
  end

end

Fügen Sie dies zum Aktivieren zu config / environment / test.rb und config / environment / development.rb hinzu:

config.middleware.use "PrettyJsonResponse"

Vermeiden Sie die Verwendung in der Produktion, da @gertas in seiner Version dieser Lösung warnt. Es ist etwas langsam.

Mit Schienen getestet 4.1.6.

#At Controller
def branch
    @data = Model.all
    render json: JSON.pretty_generate(@data.as_json)
end

Hier ist meine Lösung, die ich während meiner eigenen Suche aus anderen Posts abgeleitet habe.

Auf diese Weise können Sie die pp- und jj-Ausgabe nach Bedarf an eine Datei senden.

require "pp"
require "json"

class File
  def pp(*objs)
    objs.each {|obj|
      PP.pp(obj, self)
    }
    objs.size <= 1 ? objs.first : objs
  end
  def jj(*objs)
    objs.each {|obj|
      obj = JSON.parse(obj.to_json)
      self.puts JSON.pretty_generate(obj)
    }
    objs.size <= 1 ? objs.first : objs
  end
end

test_object = { :name => { first: "Christopher", last: "Mullins" }, :grades => [ "English" => "B+", "Algebra" => "A+" ] }

test_json_object = JSON.parse(test_object.to_json)

File.open("log/object_dump.txt", "w") do |file|
  file.pp(test_object)
end

File.open("log/json_dump.txt", "w") do |file|
  file.jj(test_json_object)
end

Ich habe das Juwel CodeRay verwendet und es funktioniert ziemlich gut. Das Format enthält Farben und erkennt viele verschiedene Formate.

Ich habe es für ein Juwel verwendet, das zum Debuggen von Rails-APIs verwendet werden kann, und es funktioniert ziemlich gut.

Der Edelstein heißt übrigens 'api_explorer' ( http://www.github.com/toptierlabs/api_explorer )

Wenn Sie dies schnell in einer Rails-Controller-Aktion implementieren möchten, um eine JSON-Antwort zu senden:

def index
  my_json = '{ "key": "value" }'
  render json: JSON.pretty_generate( JSON.parse my_json )
end

Wenn Sie RABL verwenden , können Sie es wie hier beschrieben für die Verwendung von JSON.pretty_generate konfigurieren:

class PrettyJson
  def self.dump(object)
    JSON.pretty_generate(object, {:indent => "  "})
  end
end

Rabl.configure do |config|
  ...
  config.json_engine = PrettyJson if Rails.env.development?
  ...
end

Ein Problem bei der Verwendung von JSON.pretty_generate besteht darin, dass JSON-Schemaüberprüfer mit Ihren datetime-Zeichenfolgen nicht mehr zufrieden sind. Sie können diese in Ihrer config / initializers / rabl_config.rb beheben mit:

ActiveSupport::TimeWithZone.class_eval do
  alias_method :orig_to_s, :to_s
  def to_s(format = :default)
    format == :default ? iso8601 : orig_to_s(format)
  end
end

# example of use:
a_hash = {user_info: {type: "query_service", e_mail: "my@email.com", phone: "+79876543322"}, cars_makers: ["bmw", "mitsubishi"], car_models: [bmw: {model: "1er", year_mfc: 2006}, mitsubishi: {model: "pajero", year_mfc: 1997}]}
pretty_html = a_hash.pretty_html

# include this module to your libs:
module MyPrettyPrint
    def pretty_html indent = 0
        result = ""
        if self.class == Hash
            self.each do |key, value|
                result += "#{key}
: #{[Array, Hash].include?(value.class) ? value.pretty_html(indent+1) : value}
"
            end
        elsif self.class == Array
            result = "[#{self.join(', ')}]"
        end
        "#{result}"
    end

end

class Hash
    include MyPrettyPrint
end

class Array
    include MyPrettyPrint
end

Ich verwende Folgendes, da ich die Header, den Status und die JSON-Ausgabe als Satz nützlich finde. Die Anrufroutine wird auf Empfehlung einer Railscasts-Präsentation unter http://railscasts.com/episodes/151-rack-middleware?autoplay=true aufgeschlüsselt

  class LogJson

  def initialize(app)
    @app = app
  end

  def call(env)
    dup._call(env)
  end

  def _call(env)
    @status, @headers, @response = @app.call(env)
    [@status, @headers, self]
  end

  def each(&block)
    if @headers["Content-Type"] =~ /^application\/json/
      obj = JSON.parse(@response.body)
      pretty_str = JSON.pretty_unparse(obj)
      @headers["Content-Length"] = Rack::Utils.bytesize(pretty_str).to_s
      Rails.logger.info ("HTTP Headers:  #{ @headers } ")
      Rails.logger.info ("HTTP Status:  #{ @status } ")
      Rails.logger.info ("JSON Response:  #{ pretty_str} ")
    end

    @response.each(&block)
  end
  end

Hübsche Druckvariante:

my_object = { :array => [1, 2, 3, { :sample => "hash"}, 44455, 677778, 9900 ], :foo => "bar", rrr: {"pid": 63, "state": false}}
puts my_object.as_json.pretty_inspect.gsub('=>', ': ')

Ergebnis:

{"array": [1, 2, 3, {"sample": "hash"}, 44455, 677778, 9900],
 "foo": "bar",
 "rrr": {"pid": 63, "state": false}}

Das einfachste Beispiel, an das ich denken könnte:

my_json = '{ "name":"John", "age":30, "car":null }'
puts JSON.pretty_generate(JSON.parse(my_json))

Beispiel für eine Rails-Konsole:

core dev 1555:0> my_json = '{ "name":"John", "age":30, "car":null }'
=> "{ \"name\":\"John\", \"age\":30, \"car\":null }"
core dev 1556:0> puts JSON.pretty_generate(JSON.parse(my_json))
{
  "name": "John",
  "age": 30,
  "car": null
}
=> nil