tidy_json 0.1.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c8377fc4c17ae11f718b6cadd5a0bbf5a806c1706f8184370e036dbeb714d73
-  data.tar.gz: dd9dcac5f8b3294f1edbd7a05762ad89277e6b593b0610d79d501e3d68e62fea
+  metadata.gz: 595bfb60293652c3aec843420229bfe1c55c84a8387c7f60e5b4d5a62f47a9df
+  data.tar.gz: 5ac9762a852f6753ff1bb8c52a2eac9224a55455bd14c9cf817377138fe21233
 SHA512:
-  metadata.gz: 62b421c64ac5ecbd6fcc54a9e43f57d1e04ae52b6b6ab21c5eb65d65b4a267e44a28dde2ee67cf80167c5d0857c242c246e3881d510f00493e44b835fb17b52a
-  data.tar.gz: 0b7534efee7f35486f1bc8f60dab7031f762aa6fdc69a7eb83d603b2cfae25583aa702e4009ff8dba284a0e1b3136e0c4bafe39f43e235951d7bc93a767eca1a
+  metadata.gz: 4e1bbd8d6caf301d83b83793188a0d4d8620876ed7930a4d38103aea5e5e9b79106762bb1b4caf0b03828d8e4713a0e1703bebe17dd12551f6d094d389865df3
+  data.tar.gz: dfac6e1f21f516cd8311d3777497c0f2ab1563d4303b719c5faf2b3b7250d16ac4e4ffd429fe6abde5b67b78908dc1c3f6651854269253b747cb3b1ef10399b7

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 Robert Di Pardo
+Copyright (c) 2019-2020 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,24 +1,16 @@
-# TidyJson
+# tidy_json
 
-[![Build Status](https://travis-ci.com/rdipardo/tidy_json.svg)](https://travis-ci.com/rdipardo/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]
 
 A mixin providing (recursive) JSON serialization and pretty printing.
 
 ### Installation
 
-#### Minimal
-
-```bash
-    $ gem install tidy_json
-```
-
-#### Development (tests, YARD docs)
-
 ```bash
-    $ gem install -​-development tidy_json
+$ gem install tidy_json
 ```
 
-Or, with `bundler`:
+Or, in your `Gemfile`:
 
 ```ruby
 source 'https://rubygems.org'
@@ -32,21 +24,71 @@ gem 'tidy_json'
 ```ruby
 require 'tidy_json'
 
-JSON.parse [].stringify
-# => {"class"=>"Array"}
+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] }
+  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"]}>
 
-complex_object = { :a => 1, :b => ['two', 3, '<abbr title="four">IV</abbr>'] }
-# => {:a=>1, :b=>["two", 3, "<abbr title=\"four\">IV</abbr>"]}
+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"]}}
 
-puts complex_object.to_tidy_json
+puts my_jsonable.to_tidy_json(indent: 4, sort: true)
 # {
-# "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": "一",
+#                     "ni": "二",
+#                     "san": "三",
+#                     "yon": "四"
+#                 }
+#             ]
+#         ]
+#     },
+#     "b": {
+#         "a": 1,
+#         "b": [
+#             "two",
+#             3,
+#             "<abbr title=\"four\">IV</abbr>"
+#         ],
+#         "f": [
+#             "x",
+#             "y",
+#             "z"
+#         ],
+#         "g": [
+#             {
+#                 "none": []
+#             }
+#         ],
+#         "z": {
+#             "i": "one",
+#             "ii": "duos",
+#             "iii": 3,
+#             "iv": 4
+#         }
+#     },
+#     "class": "Jsonable"
 # }
 # => nil
 ```
@@ -57,12 +99,19 @@ puts complex_object.to_tidy_json
 - [json](https://rubygems.org/gems/json) ~> 2.2
 
 #### Building
-- [bundler](https://rubygems.org/gems/bundler) ~> 2.1
-- [minitest](https://rubygems.org/gems/minitest) ~> 5.0
+- [test-unit](https://rubygems.org/gems/test-unit) ~> 3.3
 - [yard](https://rubygems.org/gems/yard) ~> 0.9
 
 ### License
-[MIT](https://opensource.org/licenses/MIT)
+[MIT](https://github.com/rdipardo/tidy_json/blob/master/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
 
-### Author
-[Robert Di Pardo](mailto:rdipardo0520@conestogac.on.ca)

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,3 +1,5 @@
+# frozen_string_literal: false
+
 require 'json'
 require_relative 'tidy_json/version'
 
@@ -9,16 +11,20 @@ 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 = {})
+  def self.tidy(obj = {}, opts = {})
+    formatter = Formatter.new(opts)
+    obj = sort_keys(obj) if formatter.sorted
     str = ''
 
     if obj.instance_of?(Hash)
       str << "{\n"
 
       obj.each do |k, v|
-        str << "\"#{k}\": "
-        str << Serializer.format_node(v, obj)
+        str << formatter.indent << "\"#{k}\": "
+        str << formatter.format_node(v, obj)
       end
 
       str << "}\n"
@@ -27,29 +33,72 @@ module TidyJson
       str << "[\n"
 
       obj.each do |v|
-        str << Serializer.format_node(v, obj)
+        str << formatter.indent
+        str << formatter.format_node(v, obj)
       end
 
       str << "]\n"
     end
 
-    str
+    formatter.trim str
   end
 
   ##
-  # Like +TidyJson::tidy+, but callable by the sender object with the option *not* to pretty-print.
+  # Returns the given +obj+ with keys in ascending order to a maximum depth of
+  # 2.
   #
-  # @param pretty [Boolean] Whether or not the returned string should be pretty-printed.
-  # @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
+  # @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
-    else
-      if pretty then TidyJson.tidy(self)
-      else to_json
+
+      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
+
+      temp.keys.each { |k| sorted << temp[k] }
+    else
+      sorted = sorter.call(obj, {})
+    end
+
+    sorted
+  end
+
+  ##
+  # Like +TidyJson::tidy+, but callable by the sender object.
+  #
+  # @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(self, opts)
+    else
+      TidyJson.tidy(JSON.parse(stringify), opts)
     end
   end
 
@@ -70,20 +119,29 @@ 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>_<current_UNIX_time></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
 
@@ -93,17 +151,8 @@ module TidyJson
   # @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+.
+    # 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.
@@ -127,7 +176,7 @@ module TidyJson
             nested = nil
 
             val.each.any? do |k, v|
-              if v.instance_variables.first
+              unless v.instance_variables.empty?
                 nested_key = k
                 nested = v
               end
@@ -138,7 +187,8 @@ module TidyJson
             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)
+                json_hash[key][pos] = serialize(nested,
+                                                class: nested.class.name)
               end
             end
 
@@ -149,51 +199,48 @@ module TidyJson
             val.each do |elem|
               i = val.index(elem)
 
-              # multi-dimensional array
-              if elem.instance_of?(Array)
+              # member is a multi-dimensional collection
+              if elem.respond_to?(:each)
                 nested = []
                 elem.each do |e|
-                  j = elem.index(e)
+                  j = if elem.respond_to?(:key)
+                        elem.key(e)
+                      else elem.index(e)
+                      end
 
-                  # nested array element is a class object
-                  if e.instance_variables.first
+                  # 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])
-                  else
-                    # some kind of collection?
-                    if e.respond_to? :each
-                      temp = []
-                      e.each { |el| temp << el }
-                      nested << temp
-                    else nested << e
+
+                  # 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
 
-              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
+              # 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
@@ -201,7 +248,7 @@ module TidyJson
           # 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
+            if !val.instance_variables.empty?
               class_elem = { class: val.class.name }
               json_hash[key] << class_elem
               k = json_hash[key].index(class_elem)
@@ -210,23 +257,20 @@ module TidyJson
               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
+          # 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
@@ -238,143 +282,221 @@ module TidyJson
       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 => Object}, <Object>] The enumerable object containing +node+.
+    # @param obj [{Object => #to_s}, <#to_s>] The enumerable object
+    #   containing +node+.
     # @return [String] A formatted string representation of +node+.
-    def self.format_node(node, obj)
+    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 << "\n\t[\n"
+        str << '['
+        str << "\n" unless node.empty?
 
+        # format array elements
         node.each do |elem|
           if elem.instance_of?(Hash)
-            str << "\t\t{\n"
+            str << "#{indent * 2}{"
+            str << "\n" unless elem.empty?
 
             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 << "#{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 << "\t\t}"
-            str << ',' unless node.index(elem) == (node.length - 1)
-            str << "\n" unless node.index(elem) == (node.length - 1)
+            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
-
-            if elem.instance_of?(Array) && elem.any? { |e| e.instance_of?(Array) }
-              @margins_to_backspace = elem.take_while { |e| e.instance_of?(Array) }.size
+            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 << "\t\t"
-            str << node_to_str(elem)
-            str << ",\n" unless node.index(elem) == (node.length - 1)
+            str << (indent * 2) << node_to_str(elem)
+            str << ",\n" unless node.index(elem) == node.length.pred
           end
         end
 
-        str << "\n\t]\n"
+        str << "\n#{indent}" unless node.empty?
+        str << "]\n"
 
       elsif node.instance_of?(Hash)
-        str << "\n\t{\n"
+        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? ''
-                    "\t\t\"<##{h.last.class.name.downcase}>\":"
+                    "#{indent * 2}\"<##{h.last.class.name.downcase}>\": "
                   else
-                    "\t\t\"#{h.first}\":"
+                    "#{indent * 2}\"#{h.first}\": "
                   end
-            str << key
-            str << "\n\t\t\t{\n"
+
+            str << key << '{'
+            str << "\n" unless h.last.empty?
 
             h.last.each_with_index do |inner_h, inner_h_idx|
-              str << "\t\t\t\t\"#{inner_h.first}\":"
+              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)
+              str << ",\n" unless inner_h_idx == h.last.to_a.length.pred
             end
 
-            str << "\n\t\t\t}"
+            str << "\n#{indent * 2}" unless h.last.empty?
+            str << '}'
+
+          # format scalar values
           else
-            str << "\t\t\"#{h.first}\": "
-            str << node_to_str(h.last)
+            str << "#{indent * 2}\"#{h.first}\": " << node_to_str(h.last)
           end
 
-          str << ",\n" unless idx == (node.to_a.length - 1)
+          str << ",\n" unless idx == node.to_a.length.pred
         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#{indent}" unless node.empty?
+        str << '}'
+        str << ', ' unless is_last
         str << "\n"
 
+      # scalars
       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 << ', ' unless is_last
         str << "\n"
       end
 
-      str.gsub(/\t+[\n\r]+/, '').gsub(/\}\,+/, '},').gsub(/\]\,+/, '],')
+      trim str.gsub(/(#{indent})+[\n\r]+/, '')
+              .gsub(/\}\,+/, '},')
+              .gsub(/\]\,+/, '],')
     end
-    # ~Serializer.format_node
+    # ~Formatter#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.
+    # @param tabs [Integer] 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)
+    def node_to_str(node, tabs = 0)
       graft = ''
-
       tabs += 2 if tabs.zero?
-      if @should_backspace
+
+      if @need_offset
         tabs -= 1
-        @margins_to_backspace -= 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" << ("\t" * tabs).to_s << n
+          graft << "\n" << indent << n
         end
 
       elsif node.instance_of?(Array)
-        @should_backspace = @margins_to_backspace.positive?
+        @need_offset = @left_bracket_offset.positive?
 
         format_node(node, {}).scan(/.*$/) do |n|
-          graft << "\n" << ("\t" * tabs).to_s << n
+          graft << "\n" << indent << n
         end
 
       elsif !node.instance_of?(String) then graft << node.to_s
+
       else graft << "\"#{node.gsub(/\"/, '\\"')}\""
       end
 
-      graft.rstrip
+      graft.strip
     end
-    # ~Serializer.node_to_str
+    # ~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
-  # ~Serializer
+  # ~Formatter
 
   private_constant :Serializer
+  private_constant :Formatter
 end
 # ~TidyJson
 
 ##
-# Exposes the +TidyJson+ mixin to all Ruby objects.
+# Includes +TidyJson+ in every Ruby class.
 # ====
 #  class Object
 #    include TidyJson