tidy_json 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 595bfb60293652c3aec843420229bfe1c55c84a8387c7f60e5b4d5a62f47a9df
-  data.tar.gz: 5ac9762a852f6753ff1bb8c52a2eac9224a55455bd14c9cf817377138fe21233
+  metadata.gz: 63e286aa3b914d96b71dc8e32904e0ca0514deb1159bf9a8ef40978f7b2a2ea0
+  data.tar.gz: f7f30ca7fab2e95b93b4aa385d5e2a4752899b273a160e8a64151c68248fb0d5
 SHA512:
-  metadata.gz: 4e1bbd8d6caf301d83b83793188a0d4d8620876ed7930a4d38103aea5e5e9b79106762bb1b4caf0b03828d8e4713a0e1703bebe17dd12551f6d094d389865df3
-  data.tar.gz: dfac6e1f21f516cd8311d3777497c0f2ab1563d4303b719c5faf2b3b7250d16ac4e4ffd429fe6abde5b67b78908dc1c3f6651854269253b747cb3b1ef10399b7
+  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/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 @@
 # tidy_json
 
-[![Travis CI][travis_build_status_badge]][travis_build_status]  [![Circle CI][cci_build_status_badge]][cci_build_status]  [![codecov][codecov_badge]][codecov_status]  [![Gem Version][gem_version_badge]][gem_version]
+![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
@@ -28,26 +35,26 @@ class Jsonable
   attr_reader :a, :b
   def initialize
     @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: 'duos', iii: 3, i: 'one' }, b: ['two', 3, '<abbr title="four">IV</abbr>'], a: 1, g: [{ none: [] }], f: %w[x y z] }
+    @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
 
 my_jsonable = Jsonable.new
-# => #<Jsonable:0x0055b2aa0ff660 @a={:a=>"uno", :f=>["I", "II", "III", ["i.", "ii.", "iii.", {:ichi=>"一", :ni=>"二", :san=>"三", :yon=>"四"}]], :c=>{}, :b=>"dos", :e=>[[]]}, @b={:z=>{:iv=>4, :ii=>"duos", :iii=>3, :i=>"one"}, :b=>["two", 3, "<abbr title=\"four\">IV</abbr>"], :a=>1, :g=>[{:none=>[]}], :f=>["x", "y", "z"]}>
+# => #<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"=>"duos", "iii"=>3, "i"=>"one"}, "b"=>["two", 3, "<abbr title=\"four\">IV</abbr>"], "a"=>1, "g"=>[{"none"=>[]}], "f"=>["x", "y", "z"]}}
+# => "{\"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 my_jsonable.to_tidy_json(indent: 4, sort: true)
+puts my_jsonable.to_tidy_json(indent: 4, sort: true, space_before: 2, ascii_only: true)
 # {
-#     "a": {
-#         "a": "uno",
-#         "b": "dos",
-#         "c": {},
-#         "e": [
+#     "a"  : {
+#         "a"  : "uno",
+#         "b"  : "dos",
+#         "c"  : {},
+#         "e"  : [
 #             []
 #         ],
-#         "f": [
+#         "f"  : [
 #             "I",
 #             "II",
 #             "III",
@@ -56,62 +63,58 @@ puts my_jsonable.to_tidy_json(indent: 4, sort: true)
 #                 "ii.",
 #                 "iii.",
 #                 {
-#                     "ichi": "一",
-#                     "ni": "二",
-#                     "san": "三",
-#                     "yon": "四"
+#                     "ichi"  : "\u4e00",
+#                     "ni"  : "\u4e8c",
+#                     "san"  : "\u4e09",
+#                     "yon"  : "\u56db"
 #                 }
 #             ]
 #         ]
 #     },
-#     "b": {
-#         "a": 1,
-#         "b": [
-#             "two",
+#     "b"  : {
+#         "a"  : 1,
+#         "b"  : [
+#             "deux",
 #             3,
 #             "<abbr title=\"four\">IV</abbr>"
 #         ],
-#         "f": [
+#         "f"  : [
 #             "x",
 #             "y",
 #             "z"
 #         ],
-#         "g": [
+#         "g"  : [
 #             {
-#                 "none": []
+#                 "none"  : []
 #             }
 #         ],
-#         "z": {
-#             "i": "one",
-#             "ii": "duos",
-#             "iii": 3,
-#             "iv": 4
+#         "z"  : {
+#             "i"  : "uno",
+#             "ii"  : "dos",
+#             "iii"  : 3,
+#             "iv"  : 4
 #         }
 #     },
-#     "class": "Jsonable"
+#     "class"  : "Jsonable"
 # }
 # => nil
 ```
 
-### Dependencies
-
-#### Runtime
-- [json](https://rubygems.org/gems/json) ~> 2.2
-
-#### Building
-- [test-unit](https://rubygems.org/gems/test-unit) ~> 3.3
-- [yard](https://rubygems.org/gems/yard) ~> 0.9
-
 ### License
-[MIT](https://github.com/rdipardo/tidy_json/blob/master/LICENSE)
+Distributed under the terms of the [MIT License][].
 
 
 [travis_build_status]: https://travis-ci.com/rdipardo/tidy_json
-[travis_build_status_badge]: https://travis-ci.com/rdipardo/tidy_json.svg?branch=master
 [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
-[codecov_status]: https://codecov.io/gh/rdipardo/tidy_json
-[codecov_badge]: https://codecov.io/gh/rdipardo/tidy_json/badge.svg
-[gem_version]: https://badge.fury.io/rb/tidy_json
-[gem_version_badge]: https://badge.fury.io/rb/tidy_json.svg
-
+[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/lib/tidy_json.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: false
 
 require 'json'
+require_relative 'tidy_json/serializer'
+require_relative 'tidy_json/formatter'
 require_relative 'tidy_json/version'
 
 ##
@@ -16,31 +18,32 @@ module TidyJson
   # @return [String] A pretty-printed JSON string.
   def self.tidy(obj = {}, opts = {})
     formatter = Formatter.new(opts)
-    obj = sort_keys(obj) if formatter.sorted
-    str = ''
+    json = ''
 
-    if obj.instance_of?(Hash)
-      str << "{\n"
-
-      obj.each do |k, v|
-        str << formatter.indent << "\"#{k}\": "
-        str << formatter.format_node(v, obj)
-      end
-
-      str << "}\n"
+    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]
 
-    elsif obj.instance_of?(Array)
-      str << "[\n"
+        obj.each do |k, v|
+          str << formatter.format[:indent] << "\"#{k}\": "
+          str << formatter.format_node(v, obj)
+        end
 
-      obj.each do |v|
-        str << formatter.indent
-        str << formatter.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
-
-    formatter.trim str
   end
 
   ##
@@ -80,7 +83,7 @@ module TidyJson
         temp[idx] = sorter.call(h, {})
       end
 
-      temp.keys.each { |k| sorted << temp[k] }
+      temp.each_key { |k| sorted << temp[k] }
     else
       sorted = sorter.call(obj, {})
     end
@@ -95,11 +98,7 @@ module TidyJson
   # @option (see Formatter#initialize)
   # @return [String] A pretty-printed JSON string.
   def to_tidy_json(opts = {})
-    if instance_variables.empty?
-      TidyJson.tidy(self, opts)
-    else
-      TidyJson.tidy(JSON.parse(stringify), opts)
-    end
+    TidyJson.tidy(self, opts)
   end
 
   ##
@@ -144,356 +143,7 @@ module TidyJson
   rescue Errno::ENOENT, Errno::EACCES, IOError, RuntimeError, NoMethodError => e
     warn "#{__FILE__}.#{__LINE__}: #{e.message}"
   end
-
-  ##
-  # A purpose-built JSON generator.
-  #
-  # @api private
-  class Serializer
-    ##
-    # 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|
-              unless v.instance_variables.empty?
-                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)
-
-              # member is a multi-dimensional collection
-              if elem.respond_to?(:each)
-                nested = []
-                elem.each do |e|
-                  j = if elem.respond_to?(:key)
-                        elem.key(e)
-                      else elem.index(e)
-                      end
-
-                  # nested element is a class object
-                  if !e.instance_variables.empty?
-                    json_hash[key][j] = { class: e.class.name }
-
-                    # recur over the contained object
-                    serialize(e, json_hash[key][j])
-
-                  # some kind of collection?
-                  elsif e.respond_to?(:each)
-                    temp = []
-                    e.each do |el|
-                      temp << if el.instance_variables.empty? then el
-                              else JSON.parse(el.stringify)
-                              end
-                    end
-
-                    nested << temp
-
-                  # scalar type
-                  else nested << e
-                  end
-                end
-                # ~iteration of nested array elements
-
-                json_hash[key] << nested
-
-              # member is a flat array
-              elsif !elem.instance_variables.empty? # class object?
-                json_hash[key] << { class: elem.class.name }
-                serialize(elem, json_hash[key][i])
-
-              # scalar type
-              else json_hash[key] << elem
-              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.empty?
-              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 class members
-          elsif !val.instance_variables.empty? # member is a class object
-            json_hash[key] = { class: val.class.name }
-            serialize(val, json_hash[key])
-
-          # member belongs to a contained object
-          elsif json_hash.key?(key) &&
-                !json_hash[key].has_val?(val) &&
-                json_hash[key].instance_of?(Hash)
-
-            json_hash[key][key] = val
-
-          # scalar member
-          else json_hash[key] = val
-          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
-  end
-  # ~Serializer
-
-  ##
-  # A purpose-built JSON formatter.
-  #
-  # @api private
-  class Formatter
-    attr_reader :indent, :sorted
-    # @!attribute indent
-    # @return [String] the string of white space used by this +Formatter+ to
-    #   indent object members.
-
-    # @!attribute sorted
-    # @return [Boolean] whether or not this +Formatter+ will sort object
-    #   members by key name.
-
-    ##
-    # @param opts [Hash] Formatting options.
-    # @option opts [[2,4,6,8,10,12]] :indent (2) An even number of white spaces
-    #   to indent each object member.
-    # @option opts [Boolean] :sort (false) Whether or not object members should
-    #   be sorted by key.
-    def initialize(opts = {})
-      # The number of times to reduce the left indent of a nested array's
-      # opening bracket
-      @left_bracket_offset = 0
-
-      # True if printing a nested array
-      @need_offset = false
-
-      # don't test for the more explicit :integer? method because it's defined
-      # for floating point numbers also
-      valid_width = opts[:indent].positive? \
-                    if opts[:indent].respond_to?(:times) &&
-                       (2..12).step(2).include?(opts[:indent])
-      @indent = "\s" * (valid_width ? opts[:indent] : 2)
-      @sorted = opts[:sort] || false
-    end
-    # ~Formatter#initialize
-
-    ##
-    # Returns the given +node+ as pretty-printed JSON.
-    #
-    # @param node [#to_s] A visible attribute of +obj+.
-    # @param obj [{Object => #to_s}, <#to_s>] The enumerable object
-    #   containing +node+.
-    # @return [String] A formatted string representation of +node+.
-    def format_node(node, obj)
-      str = ''
-      indent = @indent
-
-      is_last = (obj.length <= 1) ||
-                (obj.length > 1 &&
-                  (obj.instance_of?(Array) &&
-                    !(node === obj.first) &&
-                      (obj.size.pred == obj.rindex(node))))
-
-      if node.instance_of?(Array)
-        str << '['
-        str << "\n" unless node.empty?
-
-        # format array elements
-        node.each do |elem|
-          if elem.instance_of?(Hash)
-            str << "#{indent * 2}{"
-            str << "\n" unless elem.empty?
-
-            elem.each_with_index do |inner_h, h_idx|
-              str << "#{indent * 3}\"#{inner_h.first}\": "
-              str << node_to_str(inner_h.last, 4)
-              str << ', ' unless h_idx == elem.to_a.length.pred
-              str << "\n"
-            end
-
-            str << (indent * 2).to_s unless elem.empty?
-            str << '}'
-            str << ',' unless node.index(elem) == node.length.pred
-            str << "\n" unless node.index(elem) == node.length.pred
-
-          # element a scalar, or a nested array
-          else
-            is_nested_array = elem.instance_of?(Array) &&
-                              elem.any? { |e| e.instance_of?(Array) }
-            if is_nested_array
-              @left_bracket_offset = \
-                elem.take_while { |e| e.instance_of?(Array) }.size
-            end
-
-            str << (indent * 2) << node_to_str(elem)
-            str << ",\n" unless node.index(elem) == node.length.pred
-          end
-        end
-
-        str << "\n#{indent}" unless node.empty?
-        str << "]\n"
-
-      elsif node.instance_of?(Hash)
-        str << '{'
-        str << "\n" unless node.empty?
-
-        # format elements as key-value pairs
-        node.each_with_index do |h, idx|
-          # format values which are hashes themselves
-          if h.last.instance_of?(Hash)
-            key = if h.first.eql? ''
-                    "#{indent * 2}\"<##{h.last.class.name.downcase}>\": "
-                  else
-                    "#{indent * 2}\"#{h.first}\": "
-                  end
-
-            str << key << '{'
-            str << "\n" unless h.last.empty?
-
-            h.last.each_with_index do |inner_h, inner_h_idx|
-              str << "#{indent * 3}\"#{inner_h.first}\": "
-              str << node_to_str(inner_h.last, 4)
-              str << ",\n" unless inner_h_idx == h.last.to_a.length.pred
-            end
-
-            str << "\n#{indent * 2}" unless h.last.empty?
-            str << '}'
-
-          # format scalar values
-          else
-            str << "#{indent * 2}\"#{h.first}\": " << node_to_str(h.last)
-          end
-
-          str << ",\n" unless idx == node.to_a.length.pred
-        end
-
-        str << "\n#{indent}" unless node.empty?
-        str << '}'
-        str << ', ' unless is_last
-        str << "\n"
-
-      # scalars
-      else
-        str << node_to_str(node)
-        str << ', ' unless is_last
-        str << "\n"
-      end
-
-      trim str.gsub(/(#{indent})+[\n\r]+/, '')
-              .gsub(/\}\,+/, '},')
-              .gsub(/\]\,+/, '],')
-    end
-    # ~Formatter#format_node
-
-    ##
-    # Returns a JSON-appropriate string representation of +node+.
-    #
-    # @param node [#to_s] A visible attribute of a Ruby object.
-    # @param tabs [Integer] Tab width at which to start printing this node.
-    # @return [String] A formatted string representation of +node+.
-    def node_to_str(node, tabs = 0)
-      graft = ''
-      tabs += 2 if tabs.zero?
-
-      if @need_offset
-        tabs -= 1
-        @left_bracket_offset -= 1
-      end
-
-      indent = @indent * (tabs / 2)
-
-      if node.nil? then graft << 'null'
-
-      elsif node.instance_of?(Hash)
-
-        format_node(node, node).scan(/.*$/) do |n|
-          graft << "\n" << indent << n
-        end
-
-      elsif node.instance_of?(Array)
-        @need_offset = @left_bracket_offset.positive?
-
-        format_node(node, {}).scan(/.*$/) do |n|
-          graft << "\n" << indent << n
-        end
-
-      elsif !node.instance_of?(String) then graft << node.to_s
-
-      else graft << "\"#{node.gsub(/\"/, '\\"')}\""
-      end
-
-      graft.strip
-    end
-    # ~Formatter#node_to_str
-
-    ##
-    # Removes any trailing comma from serialized object members.
-    #
-    # @param node [String] A serialized object member.
-    # @return [String] A copy of +node+ without a trailing comma.
-    def trim(node)
-      if (extra_comma = /(?<trail>,\s*[\]\}])$/.match(node))
-        node.sub(extra_comma[:trail],
-                 extra_comma[:trail]
-                 .slice(1, node.length.pred)
-                 .sub(/^\s/, ''))
-      else node
-      end
-    end
-    # ~Formatter#trim
-  end
-  # ~Formatter
-
-  private_constant :Serializer
-  private_constant :Formatter
 end
-# ~TidyJson
 
 ##
 # Includes +TidyJson+ in every Ruby class.