tidy_json 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16df8d716d6fcdfeba6ed6afbf5954089e172f39b61a73fa853babb5d3c2cde6
-  data.tar.gz: bc64fa60a34d16af688444e0fb706c7a087dc38ced05babcc0680bf1874fed8f
+  metadata.gz: 63e286aa3b914d96b71dc8e32904e0ca0514deb1159bf9a8ef40978f7b2a2ea0
+  data.tar.gz: f7f30ca7fab2e95b93b4aa385d5e2a4752899b273a160e8a64151c68248fb0d5
 SHA512:
-  metadata.gz: 54185c4b206f63502a061f2a8397a78697fee2eea068c77b1392f02c24d95136ecac03026c1b08b1782c554c0d3356373c367980ce857197f5c3ff2061393663
-  data.tar.gz: ba130a35229098c25b0e750dc631f725c53013eac9b69a702c26110cd321930c056f13627c066ac805a72851405cdc5203e90638def06e75396970a2c5b52b7d
+  metadata.gz: 7a55fad57a8ffd7d303bb19cbd2f89665faad9089650d7324809fb7c4f1553c27b7783d6e608d0c284b3e91617801ae100a391bb11d142d023d3f037914ed8a0
+  data.tar.gz: 612e14c4480664a0ddb64cc8caac22915a60ca3709e3b1f5cae974eae050333104c5066ba513f70c1c5686dbc096f8c2663853126d4df2bd74d62860d4375ee3

data/.yardopts

@@ -1 +1,3 @@
---private lib/*.rb lib/tidy_json/version.rb - README.md LICENSE
+--exclude lib/tidy_json/dedication.rb
+--private lib/**/*.rb
+--files README.md,LICENSE

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019-2020 Robert Di Pardo
+Copyright (c) 2019-2021 Robert Di Pardo
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,6 +1,6 @@
-# TidyJson
+# tidy_json
 
-[![Travis Build Status][travis_build_status_badge]][travis_build_status]  [![Circle CI Build Status][cci_build_status_badge]][cci_build_status]  ![Gem Version][gem_version_badge]
+![Gem Version][gem_version_badge]  ![Downloads][gem_downloads]  [![Travis CI][travis_build_status_badge]][travis_build_status]  [![Circle CI][cci_build_status_badge]][cci_build_status]  [![codecov][codecov_badge]][codecov_status]
 
 A mixin providing (recursive) JSON serialization and pretty printing.
 
@@ -19,6 +19,13 @@ gem 'tidy_json'
 # ...
 ```
 
+### Formatting Options
+
+As of version [0.3.0][], most of the same options accepted by [`JSON.generate`][]
+can be passed to `#write_json`, `#to_tidy_json`, or `TidyJson.tidy`.
+
+See [the docs][] for a current list of options and their default values.
+
 ### Example
 
 ```ruby
@@ -27,70 +34,87 @@ require 'tidy_json'
 class Jsonable
   attr_reader :a, :b
   def initialize
-    @a = { a: 'uno', b: 'dos', c: ['I', 'II', 'III', ['i.', 'ii.', 'iii.', { 'ichi': "\u{4e00}", 'ni': "\u{4e8c}", 'san': "\u{4e09}", 'yon': "\u{56db}" }]] }
-    @b = { a: 1, b: ['two', 3, '<abbr title="four">IV</abbr>'] }
+    @a = { a: 'uno', f: ['I', 'II', 'III', ['i.', 'ii.', 'iii.', { 'ichi': "\u{4e00}", 'ni': "\u{4e8c}", 'san': "\u{4e09}", 'yon': "\u{56db}" }]], c: {}, b: 'dos', e: [[]] }
+    @b = { z: { iv: 4, ii: 'dos', iii: 3, i: 'uno' }, b: ['deux', 3, '<abbr title="four">IV</abbr>'], a: 1, g: [{ none: [] }], f: %w[x y z] }
   end
 end
 
-complex_object = Jsonable.new
-puts JSON.parse complex_object.stringify
-# => {"class"=>"Jsonable", "a"=>{"a"=>"uno", "b"=>"dos", "c"=>["I", "II", "III", ["i.", "ii.", "iii.", {"ichi"=>"一", "ni"=>"二", "san"=>"三", "yon"=>"四"}]]}, "b"=>{"a"=>1, "b"=>["two", 3, "<abbr title=\"four\">IV</abbr>"]}}
+my_jsonable = Jsonable.new
+# => #<Jsonable:0x000055790c93e768 @a={:a=>"uno", :f=>["I", "II", "III", ["i.", "ii.", "iii.", {:ichi=>"一", :ni=>"二", :san=>"三", :yon=>"四"}]], :c=>{}, :b=>"dos", :e=>[[]]}, @b={:z=>{:iv=>4, :ii=>"dos", :iii=>3, :i=>"uno"}, :b=>["deux", 3, "<abbr title=\"four\">IV</abbr>"], :a=>1, :g=>[{:none=>[]}], :f=>["x", "y", "z"]}>
+
+JSON.parse my_jsonable.stringify
+# => "{\"class\":\"Jsonable\",\"a\":{\"a\":\"uno\",\"f\":[\"I\",\"II\",\"III\",[\"i.\",\"ii.\",\"iii.\",{\"ichi\":\"一\",\"ni\":\"二\",\"san\":\"三\",\"yon\":\"四\"}]],\"c\":{},\"b\":\"dos\",\"e\":[[]]},\"b\":{\"z\":{\"iv\":4,\"ii\":\"dos\",\"iii\":3,\"i\":\"uno\"},\"b\":[\"deux\",3,\"<abbr title=\\\"four\\\">IV</abbr>\"],\"a\":1,\"g\":[{\"none\":[]}],\"f\":[\"x\",\"y\",\"z\"]}}"
 
-puts complex_object.to_tidy_json
+puts my_jsonable.to_tidy_json(indent: 4, sort: true, space_before: 2, ascii_only: true)
 # {
-# "class": "Jsonable",
-# "a":
-#  {
-#    "a": "uno",
-#    "b": "dos",
-#    "c":
-#      [
-#        "I",
-#        "II",
-#        "III",
-#          [
-#            "i.",
-#            "ii.",
-#            "iii.",
-#            {
-#              "ichi":"一",
-#              "ni":"二",
-#              "san":"三",
-#              "yon":"四"
-#            }
-#          ]
-#      ]
-#   },
-# "b":
-#   {
-#     "a": 1,
-#     "b":
-#       [
-#         "two",
-#         3,
-#         "<abbr title=\"four\">IV</abbr>"
-#       ]
-#    }
+#     "a"  : {
+#         "a"  : "uno",
+#         "b"  : "dos",
+#         "c"  : {},
+#         "e"  : [
+#             []
+#         ],
+#         "f"  : [
+#             "I",
+#             "II",
+#             "III",
+#             [
+#                 "i.",
+#                 "ii.",
+#                 "iii.",
+#                 {
+#                     "ichi"  : "\u4e00",
+#                     "ni"  : "\u4e8c",
+#                     "san"  : "\u4e09",
+#                     "yon"  : "\u56db"
+#                 }
+#             ]
+#         ]
+#     },
+#     "b"  : {
+#         "a"  : 1,
+#         "b"  : [
+#             "deux",
+#             3,
+#             "<abbr title=\"four\">IV</abbr>"
+#         ],
+#         "f"  : [
+#             "x",
+#             "y",
+#             "z"
+#         ],
+#         "g"  : [
+#             {
+#                 "none"  : []
+#             }
+#         ],
+#         "z"  : {
+#             "i"  : "uno",
+#             "ii"  : "dos",
+#             "iii"  : 3,
+#             "iv"  : 4
+#         }
+#     },
+#     "class"  : "Jsonable"
 # }
 # => nil
 ```
 
-### Dependencies
-
-#### Runtime
-- [json](https://rubygems.org/gems/json) ~> 2.2
-
-#### Building
-- [bundler](https://rubygems.org/gems/bundler) ~> 1.17
-- [minitest](https://rubygems.org/gems/minitest) ~> 5.0
-- [yard](https://rubygems.org/gems/yard) ~> 0.9
-
 ### License
-[MIT](https://opensource.org/licenses/MIT)
+Distributed under the terms of the [MIT License][].
 
 
 [travis_build_status]: https://travis-ci.com/rdipardo/tidy_json
-[cci_build_status]: https://circleci.com/gh/rdipardo/tidy_json
-[travis_build_status_badge]: https://travis-ci.com/rdipardo/tidy_json.svg
+[cci_build_status]: https://circleci.com/gh/rdipardo/tidy_json/tree/master
 [cci_build_status_badge]: https://circleci.com/gh/rdipardo/tidy_json.svg?style=svg
-[gem_version_badge]: https://img.shields.io/gem/v/tidy_json
+[travis_build_status_badge]: https://travis-ci.com/rdipardo/tidy_json.svg?branch=master
+[codecov_status]: https://codecov.io/gh/rdipardo/tidy_json/branch/master
+[codecov_badge]: https://codecov.io/gh/rdipardo/tidy_json/branch/master/graph/badge.svg
+[gem_version_badge]: https://img.shields.io/gem/v/tidy_json?color=%234ec820&label=gem%20version&logo=ruby&logoColor=%23e9573f
+[gem_downloads]: https://img.shields.io/gem/dt/tidy_json?logo=ruby&logoColor=%23e9573f
+[MIT License]: https://github.com/rdipardo/tidy_json/blob/master/LICENSE
+
+<!-- API spec -->
+[`JSON.generate`]: https://github.com/flori/json/blob/d49c5de49e54a5ad3f6fcf587f98d63266ef9439/lib/json/pure/generator.rb#L111
+[the docs]: https://rubydoc.org/github/rdipardo/tidy_json/TidyJson/Formatter#initialize-instance_method
+[0.3.0]: https://github.com/rdipardo/tidy_json/releases/tag/v0.3.0

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 require 'yard'

data/lib/tidy_json.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: false
+
 require 'json'
+require_relative 'tidy_json/serializer'
+require_relative 'tidy_json/formatter'
 require_relative 'tidy_json/version'
 
 ##
@@ -9,48 +13,92 @@ module TidyJson
   # Emits a pretty-printed JSON representation of the given +obj+.
   #
   # @param obj [Object] A Ruby object that can be parsed as JSON.
+  # @param opts [Hash] Output format options.
+  # @option (see Formatter#initialize)
   # @return [String] A pretty-printed JSON string.
-  def self.tidy(obj = {})
-    str = ''
+  def self.tidy(obj = {}, opts = {})
+    formatter = Formatter.new(opts)
+    json = ''
+
+    begin
+      if obj.instance_variables.empty?
+        obj = sort_keys(obj) if formatter.format[:sorted]
+        json = JSON.generate(obj, formatter.format)
+      else
+        str = "{\n"
+        obj = JSON.parse(obj.stringify)
+        obj = sort_keys(obj) if formatter.format[:sorted]
 
-    if obj.instance_of?(Hash)
-      str << "{\n"
+        obj.each do |k, v|
+          str << formatter.format[:indent] << "\"#{k}\": "
+          str << formatter.format_node(v, obj)
+        end
 
-      obj.each do |k, v|
-        str << "\"#{k}\": "
-        str << Serializer.format_node(v, obj)
+        str << "}\n"
+        json = JSON.generate(JSON.parse(formatter.trim(str)), formatter.format)
       end
 
-      str << "}\n"
+      json.gsub(/[\n\r]{2,}/, "\n")
+          .gsub(/\[\s+\]/, '[]')
+          .gsub(/{\s+}/, '{}') << "\n"
+    rescue JSON::JSONError => e
+      warn "#{__FILE__}.#{__LINE__}: #{e.message}"
+    end
+  end
 
-    elsif obj.instance_of?(Array)
-      str << "[\n"
+  ##
+  # Returns the given +obj+ with keys in ascending order to a maximum depth of
+  # 2.
+  #
+  # @param obj [Hash, Array<Hash>] A dictionary-like object or collection
+  #   thereof.
+  # @return [Hash, Array<Hash>, Object] A copy of the given +obj+ with top- and
+  #   second-level keys in ascending order, or else an identical copy of +obj+.
+  # @note +obj+ is returned unchanged if: 1) it's not iterable; 2) it's an
+  #   empty collection; 3) any one of its elements is not hashable (and +obj+
+  #   is an array).
+  def self.sort_keys(obj = {})
+    return obj if !obj.respond_to?(:each) || obj.empty? ||
+                  (obj.instance_of?(Array) &&
+                   !obj.all? { |e| e.respond_to? :keys })
+
+    sorted = {}
+    sorter = lambda { |data, ret_val|
+      data.keys.sort.each do |k|
+        ret_val[k.to_sym] = if data[k].instance_of? Hash
+                              sorter.call(data[k], {})
+                            else
+                              data[k]
+                            end
+      end
+
+      return ret_val
+    }
+
+    if obj.instance_of? Array
+      temp = {}
+      sorted = []
 
-      obj.each do |v|
-        str << Serializer.format_node(v, obj)
+      (obj.sort_by { |h| h.keys.first }).each_with_index do |h, idx|
+        temp[idx] = sorter.call(h, {})
       end
 
-      str << "]\n"
+      temp.each_key { |k| sorted << temp[k] }
+    else
+      sorted = sorter.call(obj, {})
     end
 
-    str
+    sorted
   end
 
   ##
-  # Like +TidyJson::tidy+, but callable by the sender object with the option *not* to pretty-print.
+  # Like +TidyJson::tidy+, but callable by the sender object.
   #
-  # @param pretty [Boolean] Whether or not the returned string should be pretty-printed.
+  # @param opts [Hash] Output format options.
+  # @option (see Formatter#initialize)
   # @return [String] A pretty-printed JSON string.
-  def to_tidy_json(pretty = true)
-    if !instance_variables.empty?
-      if pretty then TidyJson.tidy(JSON.parse(stringify))
-      else stringify
-      end
-    else
-      if pretty then TidyJson.tidy(self)
-      else to_json
-      end
-    end
+  def to_tidy_json(opts = {})
+    TidyJson.tidy(self, opts)
   end
 
   ##
@@ -70,308 +118,32 @@ module TidyJson
   end
 
   ##
-  # Writes a pretty-printed JSON representation of the sender object to the file specified by +out+.
+  # Writes a JSON representation of the sender object to the file specified by
+  # +out+.
   #
-  # @param pretty [Boolean] Whether or not the output should be pretty-printed.
-  # @param out [String] The destination filename. Defaults to <tt><obj_class_name>_<unix timestamp></tt>.json
+  # @param out [String] The destination filename.
+  # @param opts [Hash] Output format options.
+  # @option (see Formatter#initialize)
+  # @option opts [Boolean] :tidy (false) Whether or not the output should be
+  #   pretty-printed.
   # @return [String, nil] The path to the written output file, if successful.
-  def write_json(pretty = true, out = "#{self.class.name}_#{Time.now.to_i}")
+  def write_json(out = "#{self.class.name}_#{Time.now.to_i}",
+                 opts = { tidy: false })
     path = nil
 
     File.open("#{out}.json", 'w') do |f|
-      path = f << to_tidy_json(pretty)
+      path =
+        f << if opts[:tidy] then to_tidy_json(opts)
+             elsif instance_variables.empty? then to_json
+             else stringify
+             end
     end
 
-    path.path
-  rescue IOError, RuntimeError, NoMethodError => e
+    path&.path
+  rescue Errno::ENOENT, Errno::EACCES, IOError, RuntimeError, NoMethodError => e
     warn "#{__FILE__}.#{__LINE__}: #{e.message}"
   end
-
-  ##
-  # A purpose-built JSON generator.
-  #
-  # @api private
-  class Serializer
-    ##
-    # The number of times to reduce the left margin of a nested array's opening
-    # bracket
-    @margins_to_backspace = 0
-
-    ##
-    # True if printing a nested array
-    @should_backspace = false
-
-    ##
-    # Searches +obj+ to a *maximum* depth of 2 for readable attributes,
-    # storing them as key-value pairs in +json_hash+.
-    #
-    # @param obj [Object] A Ruby object that can be parsed as JSON.
-    # @param json_hash [{String,Symbol => #to_s}] Accumulator.
-    # @return [{String => #to_s}] A hash mapping of +obj+'s visible attributes.
-    def self.serialize(obj, json_hash)
-      obj.instance_variables.each do |m|
-        key = m.to_s[/[^\@]\w*/].to_sym
-
-        next unless key && !key.eql?('')
-
-        begin
-          val = obj.send(key) # assuming readable attributes . . .
-        rescue NoMethodError # . . . which may not be always be the case !
-          json_hash[key] = nil
-        end
-
-        begin
-          # process class members of Hash type
-          if val.instance_of?(Hash)
-            nested_key = ''
-            nested = nil
-
-            val.each.any? do |k, v|
-              if v.instance_variables.first
-                nested_key = k
-                nested = v
-              end
-            end
-
-            json_hash[key] = val
-
-            if nested
-              pos = val.keys.select { |k| k === nested_key }.first.to_sym
-              nested.instance_variables.each do
-                json_hash[key][pos] = serialize(nested, class: nested.class.name)
-              end
-            end
-
-          # process class members of Array type
-          elsif val.instance_of?(Array)
-            json_hash[key] = []
-
-            val.each do |elem|
-              i = val.index(elem)
-
-              # multi-dimensional array
-              if elem.instance_of?(Array)
-                nested = []
-                elem.each do |e|
-                  j = elem.index(e)
-
-                  # nested array element is a class object
-                  if e.instance_variables.first
-                    json_hash[key][j] = { class: e.class.name }
-
-                    # recur over the contained object
-                    serialize(e, json_hash[key][j])
-                  else
-                    # some kind of collection?
-                    if e.respond_to? :each
-                      temp = []
-                      e.each { |el| temp << el }
-                      nested << temp
-                    else nested << e
-                    end
-                  end
-                end
-                # ~iteration of nested array elements
-
-                json_hash[key] << nested
-
-              else
-                # 1-D array of class objects
-                if elem.instance_variables.first
-                  json_hash[key] << { class: elem.class.name }
-                  serialize(elem, json_hash[key][i])
-                else
-                  # element of primitive type (or Array, or Hash):
-                  # leverage 1:1 mapping of Hash:object
-                  if elem.instance_of?(Hash) then json_hash[key] = val
-                  else
-                    # some kind of collection
-                    if elem.respond_to? :each
-                      temp = []
-                      elem.each { |e| temp << e }
-                      json_hash[key] << temp
-                    else json_hash[key] << elem
-                    end
-                  end
-                end
-              end
-            end
-          # ~iteration of top-level array elements
-
-          # process any nested class members, i.e., handle a recursive call
-          # to Serializer.serialize
-          elsif obj.index(val) || json_hash.key?(key)
-            if val.instance_variables.first
-              class_elem = { class: val.class.name }
-              json_hash[key] << class_elem
-              k = json_hash[key].index(class_elem)
-              serialize(val, json_hash[key][k])
-            else
-              json_hash[key] << val
-            end
-
-          # process uncollected data members
-          else
-            # member a class object
-            if val.instance_variables.first
-              json_hash[key] = { class: val.class.name }
-              serialize(val, json_hash[key])
-            else
-              # member a hash element
-              if json_hash.key?(key) && \
-                 !json_hash[key].has_val?(val) && \
-                 json_hash[key].instance_of?(Hash)
-
-                json_hash[key][key] = val
-              else
-                json_hash[key] = val
-              end
-            end
-          end
-        rescue NoMethodError
-          # we expected an array to behave like a hash, or vice-versa
-          json_hash.store(key, val) # a shallow copy is better than nothing
-        end
-      end
-      # ~iteration of instance variables
-
-      json_hash
-    end
-    # ~Serializer.serialize
-
-    ##
-    # Returns the given +node+ as pretty-printed JSON.
-    #
-    # @param node [#to_s] A visible attribute of +obj+.
-    # @param obj [{Object => Object}, <Object>] The enumerable object containing +node+.
-    # @return [String] A formatted string representation of +node+.
-    def self.format_node(node, obj)
-      str = ''
-
-      if node.instance_of?(Array)
-        str << "\n\t[\n"
-
-        node.each do |elem|
-          if elem.instance_of?(Hash)
-            str << "\t\t{\n"
-
-            elem.each_with_index do |inner_h, h_idx|
-              str << "\t\t\t\"#{inner_h.first}\":"
-              str << node_to_str(inner_h.last)
-              str << ', ' unless h_idx == (elem.to_a.length - 1)
-              str << "\n"
-            end
-
-            str << "\t\t}"
-            str << ',' unless node.index(elem) == (node.length - 1)
-            str << "\n" unless node.index(elem) == (node.length - 1)
-
-          else
-
-            if elem.instance_of?(Array) && elem.any? { |e| e.instance_of?(Array) }
-              @margins_to_backspace = elem.take_while { |e| e.instance_of?(Array) }.size
-            end
-
-            str << "\t\t"
-            str << node_to_str(elem)
-            str << ",\n" unless node.index(elem) == (node.length - 1)
-          end
-        end
-
-        str << "\n\t]\n"
-
-      elsif node.instance_of?(Hash)
-        str << "\n\t{\n"
-
-        node.each_with_index do |h, idx|
-          if h.last.instance_of?(Hash)
-            key = if h.first.eql? ''
-                    "\t\t\"<##{h.last.class.name.downcase}>\":"
-                  else
-                    "\t\t\"#{h.first}\":"
-                  end
-            str << key
-            str << "\n\t\t\t{\n"
-
-            h.last.each_with_index do |inner_h, inner_h_idx|
-              str << "\t\t\t\t\"#{inner_h.first}\":"
-              str << node_to_str(inner_h.last, 4)
-              str << ",\n" unless inner_h_idx == (h.last.to_a.length - 1)
-            end
-
-            str << "\n\t\t\t}"
-          else
-            str << "\t\t\"#{h.first}\": "
-            str << node_to_str(h.last)
-          end
-
-          str << ",\n" unless idx == (node.to_a.length - 1)
-        end
-
-        str << "\n\t}"
-        str << ', ' unless (obj.length <= 1) || \
-                           ((obj.length > 1) && \
-                           (obj.instance_of?(Hash) && \
-                             (obj.key(obj.values.last) === obj.key(node))) || \
-                           (obj.instance_of?(Array) && (obj.last == node)))
-        str << "\n"
-
-      else
-        str << node_to_str(node)
-        str << ', ' unless (obj.length <= 1) || \
-                           ((obj.length > 1) && \
-                           (obj.instance_of?(Hash) && \
-                             (obj.key(obj.values.last) === obj.key(node))) || \
-                           (obj.instance_of?(Array) && (obj.last === node)))
-        str << "\n"
-      end
-
-      str.gsub(/\t+[\n\r]+/, '').gsub(/\}\,+/, '},').gsub(/\]\,+/, '],')
-    end
-    # ~Serializer.format_node
-
-    ##
-    # Returns a JSON-appropriate string representation of +node+.
-    #
-    # @param node [#to_s] A visible attribute of a Ruby object.
-    # @param tabs [Fixnum] Tab width at which to start printing this node.
-    # @return [String] A formatted string representation of +node+.
-    def self.node_to_str(node, tabs = 0)
-      graft = ''
-
-      tabs += 2 if tabs.zero?
-      if @should_backspace
-        tabs -= 1
-        @margins_to_backspace -= 1
-      end
-
-      if node.nil? then graft << 'null'
-      elsif node.instance_of?(Hash)
-
-        format_node(node, node).scan(/.*$/) do |n|
-          graft << "\n" << ("\t" * tabs).to_s << n
-        end
-
-      elsif node.instance_of?(Array)
-        @should_backspace = @margins_to_backspace.positive?
-
-        format_node(node, {}).scan(/.*$/) do |n|
-          graft << "\n" << ("\t" * tabs).to_s << n
-        end
-
-      elsif !node.instance_of?(String) then graft << node.to_s
-      else graft << "\"#{node.gsub(/\"/, '\\"')}\""
-      end
-
-      graft.rstrip
-    end
-    # ~Serializer.node_to_str
-  end
-  # ~Serializer
-
-  private_constant :Serializer
 end
-# ~TidyJson
 
 ##
 # Includes +TidyJson+ in every Ruby class.