tidy_json 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ee82014d81eee49d6386266ea0b95ac1774291db69bdc50e32a062b7e39613e
-  data.tar.gz: fa30e666d9762736b9f61e89ce94b0ab2384df7cc7b011dd21114399d88b56e1
+  metadata.gz: e53774339fb56a01ae47f0dd087159e9a1d2fa070dccda937d5a7de399e07ba9
+  data.tar.gz: 9f6736f1c5ef84b2d4e89b507b7fa417b3ab713b01226c55c86afc54d07699ab
 SHA512:
-  metadata.gz: 0fe08f848f90052cef2c6cff40c56cd9abd7afefc9d8998091d64fa6a8f710df2682f4c7c17eac9bbdb9185b5418e7da7ecfb6e8a1f82a860b4faaa481bfb97c
-  data.tar.gz: 3b6c7bbb72b216e9759f2c822ad35e206b41faafa21f3f9eb5bb79313008ba64562d99159d1f6e2e1485e9833e8a2f7916a8c8d1a307ab929b1f77f7f32a878d
+  metadata.gz: f35fe6a646a7e47c5926e04a10222cd483f45d177d3808d3de51040404b6d9ab4fdee940ceb077dba5e74b55ca171699331896485091e6c0c1a0f7c9f1ecb422
+  data.tar.gz: d599497adc2efb538341d2b4ad09b9b7b9f47ffd30ee056f9c47ceeda42953a6a23eb8266aa87c7ed220424a4a68ec323c864f10e7a78618bd1688dd4e4d627e

data/Gemfile

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

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]
+[![Build Status][travis_build_status_badge]][travis_build_status]  [![cci_build_status_badge]][cci_build_status]  [![Gem Version][gem_version_badge]][gem_version]
 
 A mixin providing (recursive) JSON serialization and pretty printing.
 
@@ -27,47 +27,58 @@ 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}" }]], b: 'dos' }
+    @b = { z: { iv: 4, ii: 'duos', iii: 3, i: 'one' }, b: ['two', 3, '<abbr title="four">IV</abbr>'], a: 1, f: %w[x y z] }
   end
 end
 
 my_jsonable = Jsonable.new
 
 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"=>"四"}]], "b"=>"dos"}, "b"=>{"z"=>{"iv"=>4, "ii"=>"duos", "iii"=>3, "i"=>"one"}, "b"=>["two", 3, "<abbr title=\"four\">IV</abbr>"], "a"=>1, "f"=>["x", "y", "z"]}}
 
-puts my_jsonable.to_tidy_json(indent: 4)
+puts my_jsonable.to_tidy_json(indent: 4, sort: 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": "uno",
+#         "b": "dos",
+#         "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"
+#         ],
+#         "z": {
+#             "i": "one",
+#             "ii": "duos",
+#             "iii": 3,
+#             "iv": 4
+#         }
+#     },
+#     "class": "Jsonable"
 # }
 # => nil
 ```
@@ -78,15 +89,16 @@ puts my_jsonable.to_tidy_json(indent: 4)
 - [json](https://rubygems.org/gems/json) ~> 2.2
 
 #### Building
-- [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
-[cci_build_status]: https://circleci.com/gh/rdipardo/tidy_json
+[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
-[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
+[gem_version]: https://badge.fury.io/rb/tidy_json
+[gem_version_badge]: https://badge.fury.io/rb/tidy_json.svg

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,11 +11,12 @@ 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)
+    obj = sort_keys(obj) if formatter.sorted
     str = ''
 
     if obj.instance_of?(Hash)
@@ -37,14 +40,64 @@ module TidyJson
       str << "]\n"
     end
 
+    if (extra_comma = /(?<trail>,\s*[\]\}])$/.match(str))
+      str = str.sub(extra_comma[:trail],
+                    extra_comma[:trail].slice(1, str.length.pred))
+    end
+
     str
   end
 
+  ##
+  # 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.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] 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?
@@ -71,14 +124,17 @@ 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, when called.
-  #     [: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|
@@ -91,10 +147,10 @@ module TidyJson
                if opts[:tidy] then to_tidy_json(opts)
                else to_json
                end
-           end
+             end
     end
 
-    path.path
+    path&.path
   rescue IOError, RuntimeError, NoMethodError => e
     warn "#{__FILE__}.#{__LINE__}: #{e.message}"
   end
@@ -105,8 +161,8 @@ module TidyJson
   # @api private
   class Serializer
     ##
-    # 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.
@@ -130,7 +186,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
@@ -141,7 +197,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
 
@@ -152,50 +209,52 @@ module TidyJson
             val.each do |elem|
               i = val.index(elem)
 
-              # multi-dimensional array
+              # member is a 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
+                  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
-                    end
+
+                  # some kind of collection?
+                  elsif e.respond_to?(:each)
+                    temp = []
+                    e.each { |el| temp << el }
+                    nested << temp
+
+                  # primitive type
+                  else nested << e
                   end
                 end
                 # ~iteration of nested array elements
 
                 json_hash[key] << nested
 
+              # member is a flat array
               else
-                # 1-D array of class objects
-                if elem.instance_variables.first
+                # class object?
+                if !elem.instance_variables.empty?
                   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
+
+                # leverage 1:1 mapping of Hash:object
+                elsif elem.instance_of?(Hash)
+                  json_hash[key] = val
+
+                # some kind of collection
+                elsif elem.respond_to?(:each)
+                  temp = []
+                  elem.each { |e| temp << e }
+                  json_hash[key] << temp
+
+                # primitive type
+                else json_hash[key] << elem
                 end
               end
             end
@@ -204,7 +263,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)
@@ -215,20 +274,20 @@ module TidyJson
 
           # process uncollected class members
           else
-            # member a class object
-            if val.instance_variables.first
+            # member is a class object
+            if !val.instance_variables.empty?
               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
+            # 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
+
+            # primitive member
+            else json_hash[key] = val
             end
           end
         rescue NoMethodError
@@ -249,47 +308,64 @@ module TidyJson
   #
   # @api private
   class Formatter
-    attr_reader :indent
-
+    attr_reader :indent, :sorted
     # @!attribute indent
-    #   @return [String] the string of white space used by this +Formatter+ to indent object members.
+    # @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.
 
     ##
-    # Returns a new instance of +Formatter+.
-    # @param format_options [Hash] Formatting options.
-    #     [:indent] the number of white spaces to indent. The default is 2.
-    def initialize(format_options = {})
-      ##
-      # The number of times to reduce the left indent of a nested array's opening
-      # bracket
+    # @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
 
-      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)
+      # 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 format_node(node, obj)
       str = ''
       indent = @indent
 
+      # BUG: arrays containing repeated elements may produce a trailing comma
+      # since Array#index returns the first occurance; in this case the last
+      # element can't be detected by index; a temporary hack in TidyJson::tidy
+      # attempts to correct for this
+      is_last = (obj.length <= 1) ||
+                (obj.length > 1 &&
+                 (obj.instance_of?(Hash) &&
+                  (obj.key(obj.values.last) === obj.key(node))) ||
+                (obj.instance_of?(Array) && obj.size.pred == obj.index(node)))
+
       if node.instance_of?(Array)
         str << "[\n"
 
+        # format array elements
         node.each do |elem|
           if elem.instance_of?(Hash)
             str << "#{(indent * 2)}{\n"
@@ -297,23 +373,25 @@ module TidyJson
             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 << ', ' unless h_idx == elem.to_a.length.pred
               str << "\n"
             end
 
             str << "#{(indent * 2)}}"
-            str << ',' unless node.index(elem) == (node.length - 1)
-            str << "\n" unless node.index(elem) == (node.length - 1)
+            str << ',' unless node.index(elem) == node.length.pred
+            str << "\n" unless node.index(elem) == node.length.pred
 
+          # element a primitive, or a nested array
           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
+            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)
-            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
 
@@ -322,50 +400,48 @@ module TidyJson
       elsif node.instance_of?(Hash)
         str << "{\n"
 
+        # 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"
+
+            str << key << "{\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)
+              str << ",\n" unless inner_h_idx == h.last.to_a.length.pred
             end
 
             str << "\n#{indent * 2}}"
+
+          # format plain values
           else
-            str << "#{indent * 2}\"#{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#{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 << ', ' unless is_last
         str << "\n"
 
+      # format primitive types
       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(/(#{indent})+[\n\r]+/, '').gsub(/\}\,+/, '},').gsub(/\]\,+/, '],')
+      str.gsub(/(#{indent})+[\n\r]+/, '')
+         .gsub(/\}\,+/, '},')
+         .gsub(/\]\,+/, '],')
     end
     # ~Formatter#format_node
 
@@ -389,6 +465,7 @@ module TidyJson
       if node.nil? then graft << 'null'
 
       elsif node.instance_of?(Hash)
+
         format_node(node, node).scan(/.*$/) do |n|
           graft << "\n" << indent << n
         end
@@ -407,7 +484,7 @@ module TidyJson
 
       graft.strip
     end
-    # ~Formatter.node_to_str
+    # ~Formatter#node_to_str
   end
   # ~Formatter
 

data/lib/tidy_json/dedication.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 module TidyJson # :nodoc:
-  DEDICATION = "\n#{'.' * 50}\n#{'.' * 19} IN MEMORIAM #{'.' * 18}\n" \
-               "#{'.' * 16} Michael Di Pardo #{'.' * 16}\n" \
-               "#{'.' * 11} Feb 4, 1950 - Oct 28, 2019 #{'.' * 11}\n" \
-               "#{'.' * 50}\n" \
-               "#{'.' * 11} Please consider supporting #{'.' * 11}\n" \
-               "#{'.' * 13} the MS Society of Canada #{'.' * 11}\n" \
-               "#{'.' * 8} https://mssociety.ca/get-involved #{'.' * 7}\n" \
-               "#{'.' * 50}\n\n"
+  DEDICATION = "\n#{'.' * 52}\n" \
+               "#{'.' * 14} This gem is dedicated " \
+               "#{'.' * 15}\n" \
+               "#{'.' * 17} to the memory of #{'.' * 17}\n#{'.' * 52}\n" \
+               "#{'.' * 17} MICHAEL DI PARDO #{'.' * 17}\n#{'.' * 52}\n" \
+               "#{'.' * 12} Please consider supporting #{'.' * 12}\n" \
+               "#{'.' * 13} the MS Society of Canada #{'.' * 13}\n" \
+               "#{'.' * 52}\n" \
+               "#{'.' * 8} https://mssociety.ca/get-involved #{'.' * 9}\n" \
+               "#{'.' * 52}\n\n"
 end

data/lib/tidy_json/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TidyJson
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

data/test/test_tidy_json.rb

@@ -1,4 +1,6 @@
-require 'minitest/autorun'
+# frozen_string_literal: true
+
+require 'test/unit'
 require 'tidy_json'
 
 ##
@@ -13,7 +15,7 @@ class JsonableObject
   end
 end
 
-class TidyJsonTest < Minitest::Test
+class TidyJsonTest < Test::Unit::TestCase
   @@t = JsonableObject.new
   @@t2 = JsonableObject.new
   @@t3 = JsonableObject.new
@@ -27,8 +29,44 @@ class TidyJsonTest < Minitest::Test
   end
 
   def test_tidy_static
-    assert_equal(TidyJson.tidy(a: 'one', A: 'ONE', b: nil), "{\n  \"a\": \"one\", \n  \"A\": \"ONE\", \n  \"b\": null\n}\n")
-    assert_equal(TidyJson.tidy({}).length, 4)
+    assert_equal("{\n  \"a\": \"one\", \n  \"A\": \"ONE\", \n  \"b\": null\n}\n",
+                 TidyJson.tidy(a: 'one', A: 'ONE', b: nil))
+    assert_equal(4, TidyJson.tidy({}).length)
+  end
+
+  def test_sort_keys_static
+    hash = { c: 3, d: { i: '34', ii: '35', f: 56, a: 9 }, a: 1, b: 2 }
+    hash_array = [{ c: 3, d: { i: '34', ii: '35', f: 56, a: 9 } }, { a: 1 }, { b: 2 }]
+    assert_equal({ a: 1, b: 2, c: 3, d: { a: 9, f: 56, i: '34', ii: '35' } },
+                 TidyJson.sort_keys(hash))
+    assert_equal([{ a: 1 }, { b: 2 }, { c: 3, d: { a: 9, f: 56, i: '34', ii: '35' } }],
+                 TidyJson.sort_keys(hash_array))
+    assert_equal({ a: 'one', b: 'two', c: 3 },
+                 TidyJson.sort_keys('b': 'two', 'c': 3, 'a': 'one'))
+    assert_equal([], TidyJson.sort_keys([]), 'return empty arrays unchanged')
+    assert_equal({}, TidyJson.sort_keys({}), 'return empty hashes unchanged')
+    assert_equal([3, 2, 1], TidyJson.sort_keys([3, 2, 1]),
+                 'return arrays of keyless objects unchanged')
+    assert_equal([{ b: 'two' }, 'one'],
+                 TidyJson.sort_keys([{ 'b': 'two' }, 'one']),
+                 'arrays with any keyless objects should be returned unchanged')
+  end
+
+  def test_sort_keys_instance
+    flat_hash_array = [{ c: 3 }, { a: 1 }, { b: 2 }]
+    nested_hash_array = [{ c: 3, d: { i: '34', ii: '35', f: 56, a: 9 } }, { a: 1 }, { b: 2 }]
+    assert_equal("[\n  {\n    \"a\": 1\n  }, \n  {\n    \"b\": 2\n  }, \n  {\n    \"c\": 3\n  }\n]\n",
+                 flat_hash_array.to_tidy_json(sort: true))
+    assert_equal("[\n        {\n                \"a\": 1\n        }, \n        {\n                \"b\": 2\n        }, \n        {\n                \"c\": 3,\n                \"d\": {\n                        \"a\": 9,\n                        \"f\": 56,\n                        \"i\": \"34\",\n                        \"ii\": \"35\"\n                }\n        }\n]\n",
+                 nested_hash_array.to_tidy_json(indent: 8, sort: true))
+    assert_equal("{\n      \"a\": \"one\", \n      \"b\": \"two\", \n      \"c\": 3\n}\n",
+                 { 'b': 'two', 'c': 3, 'a': 'one' }.to_tidy_json(indent: 6, sort: true))
+    assert_equal("[\n]\n", [].to_tidy_json(sort: true))
+    assert_equal("{\n}\n", {}.to_tidy_json(sort: true))
+    assert_equal("[\n        3, \n        2, \n        1\n]\n",
+                 [3, 2, 1].to_tidy_json(indent: 8, sort: true))
+    assert_equal("[\n    {\n        \"b\": \"two\"\n    }, \n    \"one\"\n]\n",
+                 [{ 'b': 'two' }, 'one'].to_tidy_json(indent: 4, sort: true))
   end
 
   def test_tidy_instance
@@ -43,26 +81,46 @@ class TidyJsonTest < Minitest::Test
   end
 
   def test_writers
-    output = @@t.write_json
+    json_array = []
+    assert_nothing_thrown '#stringify returns valid JSON' do
+      3.times { |_| json_array << JSON.parse(@@t.stringify) }
+    end
+
+    output = json_array.write_json
     assert(File.exist?(output))
-    pretty_output = @@t.write_json('prettified', tidy: true, indent: 4)
+    assert_nothing_thrown 'Raw JSON should be valid' do
+      File.open(output, 'r') { |f| JSON.parse(f.read) }
+    end
+
+    pretty_output = \
+      json_array.write_json('prettified', tidy: true, sort: true, indent: 8)
     assert(File.exist?(pretty_output))
+    assert_nothing_thrown 'Formatted JSON should be valid' do
+      File.open(pretty_output, 'r') { |f| JSON.parse(f.read) }
+    end
   end
 
   def test_indent_bounds_checking
-    assert_equal(Object.new.to_tidy_json(indent: '8'), '')
+    assert_equal("{\n  \"a\": \"one\", \n  \"b\": \"two\", \n  \"c\": 3\n}\n",
+                 { 'b': 'two', 'c': 3, 'a': 'one' }.to_tidy_json(indent: 5, sort: true),
+                 'odd values should fall back to default of 2')
+    assert_equal([].to_tidy_json(indent: '16'), "[\n]\n",
+                 'values > 12 should fall back to default of 2')
     assert_equal('Object'.to_tidy_json(indent: []), '')
     assert_equal(0.to_tidy_json(indent: -89), '')
     assert_equal(3.1425.to_tidy_json(indent: 3.1425), '')
     assert_equal(''.to_tidy_json(indent: +0), '')
     assert_equal([].to_tidy_json(indent: -8.00009), "[\n]\n")
-    assert_equal(JSON.parse(Object.new.stringify).to_tidy_json(indent: nil),
-                 "{\n  \"class\": \"Object\"\n}\n")
-    assert_equal(JSON.parse(''.stringify).to_tidy_json(indent: -16.009),
-                 "{\n  \"class\": \"String\"\n}\n")
-    assert_equal(JSON.parse({}.stringify).to_tidy_json(indent: '8'),
-                 "{\n  \"class\": \"Hash\"\n}\n")
-    assert_equal(JSON.parse(%w[k l m].stringify).to_tidy_json(indent: '<<'),
-                 "{\n  \"class\": \"Array\"\n}\n")
+    assert_nothing_thrown '#stringify should return valid JSON even when ' \
+      'format options are invalid' do
+      assert_equal(JSON.parse(Object.new.stringify).to_tidy_json(indent: nil),
+                   "{\n  \"class\": \"Object\"\n}\n")
+      assert_equal(JSON.parse(''.stringify).to_tidy_json(indent: -16.009),
+                   "{\n  \"class\": \"String\"\n}\n")
+      assert_equal(JSON.parse({}.stringify).to_tidy_json(indent: '8'),
+                   "{\n  \"class\": \"Hash\"\n}\n")
+      assert_equal(JSON.parse(%w[k l m].stringify).to_tidy_json(indent: '<<'),
+                   "{\n  \"class\": \"Array\"\n}\n")
+    end
   end
 end

data/tidy_json.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'lib/tidy_json/version'
 require_relative 'lib/tidy_json/dedication'
 
@@ -8,9 +10,9 @@ Gem::Specification.new do |spec|
   spec.summary     = 'Serialize any Ruby object as readable JSON'
   spec.description = 'A mixin providing (recursive) JSON serialization and pretty printing.'
   spec.authors     = ['Robert Di Pardo']
-  spec.email       = 'rdipardo0520@conestogac.on.ca'
+  spec.email       = 'dipardo.r@gmail.com'
   spec.homepage    = 'https://github.com/rdipardo/tidy_json'
-  spec.metadata    = { 'documentation_uri' => 'https://rubydoc.org/github/rdipardo/tidy_json' }
+  spec.metadata    = { 'documentation_uri' => 'https://rubydoc.org/github/rdipardo/tidy_json/master' }
   spec.license     = 'MIT'
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     ['.yardopts'].concat(`git ls-files -z`.split("\x0").reject { |f| f.match(/^(\.[\w+\.]+|test|spec|features)/) })
@@ -19,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.required_ruby_version = Gem::Requirement.new('>= 2.3')
   spec.add_runtime_dependency 'json', '~> 2.2'
-  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'test-unit', '~> 3.3'
   spec.add_development_dependency 'yard', '~> 0.9'
   spec.rdoc_options = ['-x test/*']
   spec.post_install_message = TidyJson::DEDICATION

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tidy_json
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Robert Di Pardo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-23 00:00:00.000000000 Z
+date: 2020-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.9'
 description: A mixin providing (recursive) JSON serialization and pretty printing.
-email: rdipardo0520@conestogac.on.ca
+email: dipardo.r@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -72,18 +72,20 @@ homepage: https://github.com/rdipardo/tidy_json
 licenses:
 - MIT
 metadata:
-  documentation_uri: https://rubydoc.org/github/rdipardo/tidy_json
+  documentation_uri: https://rubydoc.org/github/rdipardo/tidy_json/master
 post_install_message: |2+
 
-  ..................................................
-  ................... IN MEMORIAM ..................
-  ................ Michael Di Pardo ................
-  ........... Feb 4, 1950 - Oct 28, 2019 ...........
-  ..................................................
-  ........... Please consider supporting ...........
-  ............. the MS Society of Canada ...........
-  ........ https://mssociety.ca/get-involved .......
-  ..................................................
+  ....................................................
+  .............. This gem is dedicated ...............
+  ................. to the memory of .................
+  ....................................................
+  ................. MICHAEL DI PARDO .................
+  ....................................................
+  ............ Please consider supporting ............
+  ............. the MS Society of Canada .............
+  ....................................................
+  ........ https://mssociety.ca/get-involved .........
+  ....................................................
 
 rdoc_options:
 - "-x test/*"
@@ -100,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Serialize any Ruby object as readable JSON