tidy_json 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfdad155c72b5ef6d411fbdd2dae876a4d7951e97f2f59f0817d09be0d1b1f8a
-  data.tar.gz: 40fbd785790e3dc649c1ab8ac16696b359f832cc43da577e71fe9b55a5467212
+  metadata.gz: bf122c3cc2a34f2252b766f1a47f52bada4c4ff5b5334555ea62a572848d8531
+  data.tar.gz: bcd9134752408044711fc2b4ff3732afba7b65995b9c511c9df7e8fe666df4b5
 SHA512:
-  metadata.gz: a62c5325d5ec264c61321518e26997170f5a1b34210d6c93052dfa2ab7aedce355ef0f9f9688dc4a18cd4113fafb121b314528374ba509b7e47f7a1f0f4afb7f
-  data.tar.gz: 2351e73fd6c2c6e8da966b02cec5da2eeaff8ca77a090c5ac5e7aff96122e27f12ac8c770b1b89ce943e6300e21325b099442750137ca54183fee568b8db048b
+  metadata.gz: 0d9d164a90b41f3c5793ebaa04b361a5e1c15bf8ed7580a367421e08c06bcc7cd0f5f8555adc1e9adcff57585c59554472b129797343f78714f964c45c8a7ce6
+  data.tar.gz: 950f0eab8248273ce6b80a37918226d2637f436b99552844450bec62d6b3ab40dbe887c81c6fadc4baabd53dc1a2faaac834e6e68082b17d6fd1ac0d709d16ba

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
 
-[![Build Status][travis_build_status_badge]][travis_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,74 +19,132 @@ 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
 require 'tidy_json'
 
-class JsonableObject
+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
 
-my_jsonable = JsonableObject.new
+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", "b"=>"dos", "c"=>["I", "II", "III", ["i.", "ii.", "iii.", {"ichi"=>"一", "ni"=>"二", "san"=>"三", "yon"=>"四"}]]}, "b"=>{"a"=>1, "b"=>["two", 3, "<abbr title=\"four\">IV</abbr>"]}}
+# => "{\"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: 8)
+puts my_jsonable.to_tidy_json(indent: 4, sort: true, space_before: 2, ascii_only: true)
 # {
-#        "class": "JsonableObject",
-#        "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
+### Command Line Usage
+
+After [installing the gem][], pass the name of a file containing JSON to `jtidy`
+(with or without a file extension). Run `jtidy -h` for a complete list of
+formatting options:
+
+```
+jtidy FILE[.json] [-i [2,4,6,8,10,12]] [-p [1..8]] [-v [1..8]] [-o D] [-a D] [-m N] [-e] [-A] [-N] [-s] [-P]
+    -i, --indent [2,4,6,8,10,12]     The number of spaces to indent each object member [2]
+    -p, --prop-name-space [1..8]     The number of spaces to put after property names [0]
+    -v, --value-space [1..8]         The number of spaces to put before property values [1]
+    -o, --object-delim D             A string of whitespace to delimit object members [\n]
+    -a, --array-delim D              A string of whitespace to delimit array elements [\n]
+    -m, --max-nesting N              The maximum level of data structure nesting in the generated JSON; 0 == "no depth checking" [100]
+    -e, --escape                     Escape /'s [false]
+    -A, --ascii                      Generate ASCII characters only [false]
+    -N, --nan                        Allow NaN, Infinity and -Infinity [false]
+    -s, --sort                       Sort property names [false]
+    -P, --preview                    Show preview of output [false]
+    -V, --version                    Show version
+    -h, --help                       Show this help message
+```
 
-#### Runtime
-- [json](https://rubygems.org/gems/json) ~> 2.2
+### Notice
+The `jtidy` executable bundled with this gem is in no way affiliated with, nor based on,
+the HTML parser and pretty printer [of the same name](https://github.com/jtidy/jtidy).
 
-#### Building
-- [minitest](https://rubygems.org/gems/minitest) ~> 5.0
-- [yard](https://rubygems.org/gems/yard) ~> 0.9
+The JTidy source code and binaries are licensed under the terms of the Zlib-Libpng License.
+More information is available [here](https://github.com/jtidy/jtidy/blob/master/LICENSE.txt).
 
 ### 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
+[cci_build_status]: https://circleci.com/gh/rdipardo/tidy_json/tree/testing
 [cci_build_status_badge]: https://circleci.com/gh/rdipardo/tidy_json.svg?style=svg
-[travis_build_status_badge]: https://travis-ci.com/rdipardo/tidy_json.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/testing
+[codecov_badge]: https://codecov.io/gh/rdipardo/tidy_json/branch/testing/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
+[installing the gem]: https://github.com/rdipardo/tidy_json#installation
+<!-- 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/bin/jtidy

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require 'tidy_json'
+require_relative 'jtidy_info'
+
+class Jtidy # :nodoc:
+  OPTIONS = {
+    '-i [2,4,6,8,10,12]': [:indent, Integer, '--indent [2,4,6,8,10,12]',
+                           'The number of spaces to indent each object member [2]'],
+    '-p [1..8]': [:space_before, Integer, '--prop-name-space [1..8]',
+                  'The number of spaces to put after property names [0]'],
+    '-v [1..8]': [:space, Integer, '--value-space [1..8]',
+                  'The number of spaces to put before property values [1]'],
+    '-o D': [:object_nl, String, '--object-delim D',
+             'A string of whitespace to delimit object members [\n]'],
+    '-a D': [:array_nl, String, '--array-delim D',
+             'A string of whitespace to delimit array elements [\n]'],
+    '-m N': [:max_nesting, Integer, '--max-nesting N',
+             'The maximum level of data structure nesting in the generated ' \
+             'JSON; 0 == "no depth checking" [100]'],
+    '-e': [:escape_slash, nil, '--escape', 'Escape /\'s [false]'],
+    '-A': [:ascii_only, nil, '--ascii', 'Generate ASCII characters only [false]'],
+    '-N': [:allow_nan, nil, '--nan', 'Allow NaN, Infinity and -Infinity [false]'],
+    '-s': [:sort, nil, '--sort', 'Sort property names [false]'],
+    # script-only options
+    '-P': [:preview, nil, '--preview', 'Show preview of output [false]']
+  }.freeze
+
+  def self.unescape(str)
+    str.gsub(/\\b|\\h|\\n|\\r|\\s|\\t|\\v/,
+             {
+               '\\b': "\b",
+               '\\h': "\h",
+               '\\n': "\n",
+               '\\r': "\r",
+               '\\s': "\s",
+               '\\t': "\t",
+               '\\v': "\v"
+             })
+  end
+
+  def self.show_unused(opts)
+    return if opts.empty?
+
+    ignored = opts.keys.map do |key|
+      (OPTIONS.keys.select do |k|
+        OPTIONS[k][0].eql? key
+      end.first || '')[0..1]
+    end
+    warn "Ignoring options: #{(ignored.join ', ')}"
+  end
+
+  def self.parse(options)
+    format_options = {}
+    OptionParser.new do |opts|
+      opts.banner = \
+        "#{File.basename __FILE__} FILE[.json] " \
+        "#{(OPTIONS.keys.map { |k| "[#{k}]" }).join ' '}"
+      OPTIONS.each_key do |k|
+        opt, type, long_name, desc = OPTIONS[k]
+        opts.on(k, long_name, type, desc) do |v|
+          format_options[opt] = (type == String ? unescape(v) : v)
+        end
+      end
+
+      opts.on_tail('-V', '--version', 'Show version') do
+        show_unused format_options
+        puts ::JtidyInfo.new.to_s
+        exit 0
+      end
+
+      opts.on_tail('-h', '--help', 'Show this help message') do
+        show_unused format_options
+        puts opts
+        exit 0
+      end
+    end.parse! options
+
+    format_options
+  end
+
+  private_class_method :unescape, :show_unused
+end
+
+begin
+  begin
+    OPTS = Jtidy.parse(ARGV).freeze
+    INPUT_FILE = ARGV[0].freeze
+  rescue OptionParser::InvalidOption => e
+    warn e.message.capitalize
+    raise OptionParser::InvalidArgument
+  end
+
+  if !INPUT_FILE.nil? && !INPUT_FILE.empty?
+    tidy = ''
+    fname = INPUT_FILE.gsub('\\', '/')
+    ext = File.extname(fname)
+    input = File.join(
+      File.expand_path(File.dirname(fname)), File.basename(fname, ext)
+    )
+
+    begin
+      File.open((input + '.json').to_s, 'r') do |json|
+        begin
+          tidy = TidyJson.tidy(JSON.parse(json.read.strip), OPTS)
+        rescue JSON::JSONError => e
+          warn "#{__FILE__}.#{__LINE__}: #{e.message}"
+        end
+      end
+
+      if tidy.length.positive?
+        output = (input + '-tidy.json').to_s
+        File.open(output, 'w') { |fd| fd.write(tidy) }
+        puts "\nWrote: #{output}"
+        puts "#{tidy[0..1024]}\n . . ." if OPTS[:preview]
+      end
+    rescue Errno::ENOENT, Errno::EACCES, IOError => e
+      warn "#{__FILE__}.#{__LINE__}: #{e.message}"
+    end
+
+  else
+    Jtidy.parse %w[--help]
+  end
+rescue OptionParser::InvalidArgument, OptionParser::MissingArgument
+  Jtidy.parse %w[--help]
+end

data/bin/jtidy_info.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TidyJson # :nodoc:
+  class JtidyInfo
+    NOTICE = [
+      '#',
+      '# jtidy is in no way affiliated with, nor based on, ',
+      '# the HTML parser and pretty printer of the same name.',
+      '#',
+      '# The JTidy source code and binaries are licensed under',
+      '# the terms of the Zlib-Libpng License.',
+      '#',
+      '# More information is available here:',
+      '# https://github.com/jtidy/jtidy/blob/master/LICENSE.txt',
+      '#'
+    ].join("\n").freeze
+
+    attr_reader :meta
+
+    def initialize
+      gem = Gem::Specification.find_by_name('tidy_json')
+      @meta = {
+        name: "jtidy #{gem.version}",
+        license: "License: #{gem.license}",
+        bugs: "Bugs: #{gem.metadata['bug_tracker_uri']}",
+        notice: NOTICE
+      }
+    end
+
+    def to_s
+      (@meta.values.join "\n").freeze
+    end
+  end
+end

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,49 +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] Formatting options.
-  #     [:indent] the number of white spaces to indent
+  # @param opts [Hash] Output format options.
+  # @option (see Formatter#initialize)
   # @return [String] A pretty-printed JSON string.
   def self.tidy(obj = {}, opts = {})
     formatter = Formatter.new(opts)
-    str = ''
+    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 << formatter.indent << "\"#{k}\": "
-        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
+  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
 
-      obj.each do |v|
-        str << formatter.indent
-        str << formatter.format_node(v, obj)
+      return ret_val
+    }
+
+    if obj.instance_of? Array
+      temp = {}
+      sorted = []
+
+      (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.
   #
-  # @param opts [Hash] Formatting options.
-  #     [:indent] the number of white spaces to indent
+  # @param opts [Hash] Output format options.
+  # @option (see Formatter#initialize)
   # @return [String] A pretty-printed JSON string.
   def to_tidy_json(opts = {})
-    if !instance_variables.empty?
-      TidyJson.tidy(JSON.parse(stringify), opts)
-    else
-      TidyJson.tidy(self, opts)
-    end
+    TidyJson.tidy(self, opts)
   end
 
   ##
@@ -71,337 +118,32 @@ module TidyJson
   end
 
   ##
-  # Writes a 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 out [String] The destination filename.
-  # @param opts [Hash] Formatting options for this object's +#to_tidy_json+ method.
-  #     [:tidy] whether or not the output should be pretty-printed
-  #     [:indent] the number of white spaces to indent
+  # @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(out = "#{self.class.name}_#{Time.now.to_i}", opts = { tidy: false })
+  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(opts)
+      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
-    ##
-    # 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 class 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
-  end
-  # ~Serializer
-
-  ##
-  # A purpose-built JSON formatter.
-  #
-  # @api private
-  class Formatter
-    attr_reader :indent
-
-    # @!attribute indent
-    #   @return [String] the string of white space used by this +Formatter+ to indent object members.
-
-    def initialize(format_options = {})
-      ##
-      # 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
-
-      indent_width = format_options[:indent]
-
-      # don't use the more explicit #integer? method because it's defined for
-      # floating point numbers also
-      good_width = indent_width.positive? if indent_width.respond_to? :times
-
-      @indent = "\s" * (good_width ? indent_width : 2)
-    end
-
-    ##
-    # 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 format_node(node, obj)
-      str = ''
-      indent = @indent
-
-      if node.instance_of?(Array)
-        str << "[\n"
-
-        node.each do |elem|
-          if elem.instance_of?(Hash)
-            str << "#{(indent * 2)}{\n"
-
-            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 - 1)
-              str << "\n"
-            end
-
-            str << "#{(indent * 2)}}"
-            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) }
-              @left_bracket_offset = elem.take_while { |e| e.instance_of?(Array) }.size
-            end
-
-            str << (indent * 2)
-            str << node_to_str(elem)
-            str << ",\n" unless node.index(elem) == (node.length - 1)
-          end
-        end
-
-        str << "\n#{indent}]\n"
-
-      elsif node.instance_of?(Hash)
-        str << "{\n"
-
-        node.each_with_index do |h, idx|
-          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"
-
-            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 - 1)
-            end
-
-            str << "\n#{indent * 2}}"
-          else
-            str << "#{indent * 2}\"#{h.first}\": "
-            str << node_to_str(h.last)
-          end
-
-          str << ",\n" unless idx == (node.to_a.length - 1)
-        end
-
-        str << "\n#{indent}}"
-        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(/(#{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
-  end
-  # ~Formatter
-
-  private_constant :Serializer
-  private_constant :Formatter
 end
-# ~TidyJson
 
 ##
 # Includes +TidyJson+ in every Ruby class.