ruby on rails - रेल पर रुबी में मैं अपने जेएसओएन आउटपुट को "सुंदर" कैसे बना सकता हूं?




ruby-on-rails json (11)

HTML में <pre> टैग, JSON.pretty_generate साथ उपयोग किया जाता है, JSON को आपके दृश्य में सुंदर प्रस्तुत करेगा। मैं बहुत खुश था जब मेरे शानदार मालिक ने मुझे यह दिखाया:

<% if [email protected]? %>
   <pre><%= JSON.pretty_generate(@data) %></pre>
<% end %>

मैं रेल पर रूबी में अपने जेएसओएन आउटपुट को "सुंदर" या अच्छी तरह से स्वरूपित करना चाहता हूं।

अभी, मैं to_json कॉल करता to_json और मेरा JSON एक पंक्ति पर है। कभी-कभी यह देखना मुश्किल हो सकता है कि JSON आउटपुट स्ट्रीम में कोई समस्या है या नहीं।

क्या मेरे JSON को "सुंदर" या अच्छी तरह से रेल में स्वरूपित करने का तरीका कॉन्फ़िगर करने का तरीका है?


JSON के बाद के संस्करणों में निर्मित pretty_generate() फ़ंक्शन का उपयोग करें। उदाहरण के लिए:

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

जो आपको मिलता है:

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

मैं निम्नलिखित का उपयोग करता हूं क्योंकि मुझे हेडर, स्थिति और JSON आउटपुट को सेट के रूप में उपयोगी लगता है। रेलवे की प्रस्तुति से अनुशंसा पर कॉल रूटीन टूट गया है: http://railscasts.com/episodes/151-rack-middleware?autoplay=true

  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

मैंने मणि CodeRay का उपयोग किया है और यह बहुत अच्छी तरह से काम करता है। प्रारूप में रंग शामिल हैं और यह कई अलग-अलग प्रारूपों को पहचानता है।

मैंने इसे एक मणि पर इस्तेमाल किया है जिसका उपयोग रेल एपीआई डिबगिंग के लिए किया जा सकता है और यह बहुत अच्छी तरह से काम करता है।

वैसे, मणि को 'api_explorer' नाम दिया गया है ( http://www.github.com/toptierlabs/api_explorer )


यदि आप RABL का उपयोग कर रहे हैं तो आप इसे JSON.pretty_generate का उपयोग करने के लिए here वर्णित अनुसार कॉन्फ़िगर कर सकते हैं:

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

JSON.pretty_generate का उपयोग करने में एक समस्या यह है कि जेएसओएन स्कीमा वैधकर्ता अब आपके डेटाटाइम स्ट्रिंग से खुश नहीं होंगे। आप उन लोगों को अपने कॉन्फ़िगर / प्रारंभकर्ता / rabl_config.rb में ठीक कर सकते हैं:

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

यदि आप JSON प्रतिक्रिया भेजने के लिए रेल नियंत्रक कार्रवाई में इसे तुरंत कार्यान्वित करना चाहते हैं:

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

यहां मेरा समाधान है जिसे मैंने अपनी खोज के दौरान अन्य पदों से लिया है।

यह आपको आवश्यकतानुसार फ़ाइल में पीपी और जेजे आउटपुट भेजने की अनुमति देता है।

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

रैक मिडलवेयर और रेल 3 के लिए धन्यवाद, आप अपने ऐप के किसी भी नियंत्रक को बदले बिना हर अनुरोध के लिए सुंदर JSON आउटपुट कर सकते हैं। मैंने इस तरह के मिडलवेयर स्निपेट लिखा है और मुझे ब्राउजर और curl आउटपुट में अच्छी तरह से मुद्रित JSON मिल गया है।

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

उपर्युक्त कोड आपके रेल प्रोजेक्ट के app/middleware/pretty_json_response.rb में रखा जाना चाहिए। और अंतिम चरण मिडलवेयर को config/environments/development.rb में पंजीकृत config/environments/development.rb :

config.middleware.use PrettyJsonResponse

मैं इसे उत्पादन.आरबी में उपयोग करने की अनुशंसा नहीं करता हूं । जेएसओएन रिपर्सिंग आपके उत्पादन ऐप के प्रतिक्रिया समय और थ्रूपुट को घटा सकता है। आखिरकार अतिरिक्त तर्क जैसे 'एक्स-प्रीटी-जेसन: सच्चे' हेडर को मांग पर मैन्युअल कर्ल अनुरोधों के लिए स्वरूपण ट्रिगर करने के लिए पेश किया जा सकता है।

(रेल 3.2.8-5.0.0 के साथ परीक्षण, रूबी 1.9.3-2.2.0, लिनक्स)


<pre> html code और pretty_generate का उपयोग करना अच्छी चाल है:

<%
  require 'json'

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

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

@gertas द्वारा इस उत्कृष्ट उत्तर से संशोधित एक मिडलवेयर समाधान यहां दिया गया है । यह समाधान रेल विशिष्ट नहीं है - इसे किसी भी रैक एप्लिकेशन के साथ काम करना चाहिए।

#Each का उपयोग करके यहां उपयोग की जाने वाली मिडलवेयर तकनीक को ASCIIcasts 151 में समझाया गया है : इफियन बेडफोर्ड द्वारा रैक मिडलवेयर

यह कोड ऐप / मिडलवेयर / 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

इसे चालू करने के लिए, इसे कॉन्फ़िगर / वातावरण / test.rb और config / वातावरण / development.rb में जोड़ें:

config.middleware.use "PrettyJsonResponse"

जैसा कि @gertas इस समाधान के अपने संस्करण में चेतावनी देता है, उत्पादन में इसका उपयोग करने से बचें। यह कुछ हद तक धीमा है।

रेल 4.1.6 के साथ परीक्षण किया।


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




pretty-print