tidy_json 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5c8377fc4c17ae11f718b6cadd5a0bbf5a806c1706f8184370e036dbeb714d73
+  data.tar.gz: dd9dcac5f8b3294f1edbd7a05762ad89277e6b593b0610d79d501e3d68e62fea
+SHA512:
+  metadata.gz: 62b421c64ac5ecbd6fcc54a9e43f57d1e04ae52b6b6ab21c5eb65d65b4a267e44a28dde2ee67cf80167c5d0857c242c246e3881d510f00493e44b835fb17b52a
+  data.tar.gz: 0b7534efee7f35486f1bc8f60dab7031f762aa6fdc69a7eb83d603b2cfae25583aa702e4009ff8dba284a0e1b3136e0c4bafe39f43e235951d7bc93a767eca1a

data/.yardopts

@@ -0,0 +1 @@
+--private lib/*.rb lib/tidy_json/version.rb - README.md LICENSE

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rake'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+# TidyJson
+
+[![Build Status](https://travis-ci.com/rdipardo/tidy_json.svg)](https://travis-ci.com/rdipardo/tidy_json)
+
+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
+```
+
+Or, with `bundler`:
+
+```ruby
+source 'https://rubygems.org'
+# ...
+gem 'tidy_json'
+# ...
+```
+
+### Example
+
+```ruby
+require 'tidy_json'
+
+JSON.parse [].stringify
+# => {"class"=>"Array"}
+
+complex_object = { :a => 1, :b => ['two', 3, '<abbr title="four">IV</abbr>'] }
+# => {:a=>1, :b=>["two", 3, "<abbr title=\"four\">IV</abbr>"]}
+
+puts complex_object.to_tidy_json
+# {
+# "a": 1,
+# "b":
+#   [
+#     "two",
+#     3,
+#     "<abbr title=\"four\">IV</abbr>"
+#   ]
+# }
+# => nil
+```
+
+### Dependencies
+
+#### Runtime
+- [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
+- [yard](https://rubygems.org/gems/yard) ~> 0.9
+
+### License
+[MIT](https://opensource.org/licenses/MIT)
+
+### Author
+[Robert Di Pardo](mailto:rdipardo0520@conestogac.on.ca)

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'yard'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+YARD::Rake::YardocTask.new
+
+desc 'Run tests'
+task default: :test

data/lib/tidy_json/dedication.rb

@@ -0,0 +1,11 @@
+module TidyJson # :nodoc:
+  DEDICATION = "#{'.' * 50}\n#{'.' * 20} tidy_json #{'.' * 19}\n" \
+               "#{'.' * 12} (c) 2019 Robert Di Pardo #{'.' * 12}\n" \
+               "#{'.' * 50}\n#{'.' * 19} IN MEMORIAM #{'.' * 18}\n" \
+               "#{'.' * 16} Michael Di Pardo #{'.' * 16}\n" \
+               "#{'.' * 19} 1950 - 2019 #{'.' * 18}\n#{'.' * 50}\n" \
+               "#{'.' * 12} Please consider supporting #{'.' * 11}\n" \
+               "#{'.' * 13} the MS Society of Canada #{'.' * 11}\n" \
+               "#{'.' * 8} https://mssociety.ca/get-involved #{'.' * 7}\n" \
+               "#{'.' * 50}\n"
+end

data/lib/tidy_json/version.rb

@@ -0,0 +1,3 @@
+module TidyJson
+  VERSION = '0.1.1'
+end

data/lib/tidy_json.rb

@@ -0,0 +1,384 @@
+require 'json'
+require_relative 'tidy_json/version'
+
+##
+# A mixin providing (recursive) JSON serialization and pretty printing.
+#
+module TidyJson
+  ##
+  # Emits a pretty-printed JSON representation of the given +obj+.
+  #
+  # @param obj [Object] A Ruby object that can be parsed as JSON.
+  # @return [String] A pretty-printed JSON string.
+  def self.tidy(obj = {})
+    str = ''
+
+    if obj.instance_of?(Hash)
+      str << "{\n"
+
+      obj.each do |k, v|
+        str << "\"#{k}\": "
+        str << Serializer.format_node(v, obj)
+      end
+
+      str << "}\n"
+
+    elsif obj.instance_of?(Array)
+      str << "[\n"
+
+      obj.each do |v|
+        str << Serializer.format_node(v, obj)
+      end
+
+      str << "]\n"
+    end
+
+    str
+  end
+
+  ##
+  # Like +TidyJson::tidy+, but callable by the sender object with the option *not* to pretty-print.
+  #
+  # @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
+      end
+    else
+      if pretty then TidyJson.tidy(self)
+      else to_json
+      end
+    end
+  end
+
+  ##
+  # Emits a JSON representation of the sender object's visible attributes.
+  #
+  # @return [String] A raw JSON string.
+  def stringify
+    json_hash = {}
+
+    begin
+      json_hash = Serializer.serialize(self, class: self.class.name)
+    rescue JSON::JSONError => e
+      warn "#{__FILE__}.#{__LINE__}: #{e.message}"
+    end
+
+    json_hash.to_json
+  end
+
+  ##
+  # Writes a pretty-printed 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
+  # @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}")
+    path = nil
+
+    File.open("#{out}.json", 'w') do |f|
+      path = f << to_tidy_json(pretty)
+    end
+
+    path.path
+  rescue IOError, RuntimeError, NoMethodError => e
+    warn "#{__FILE__}.#{__LINE__}: #{e.message}"
+  end
+
+  ##
+  # A purpose-built JSON generator.
+  #
+  # @api private
+  class Serializer
+    ##
+    # The number of times to reduce the left margin of a nested array's opening
+    # bracket
+    @margins_to_backspace = 0
+
+    ##
+    # True if printing a nested array
+    @should_backspace = false
+
+    ##
+    # Searches +obj+ to a *maximum* depth of 2 for readable attributes,
+    # storing them as key-value pairs in +json_hash+.
+    #
+    # @param obj [Object] A Ruby object that can be parsed as JSON.
+    # @param json_hash [{String,Symbol => #to_s}] Accumulator.
+    # @return [{String => #to_s}] A hash mapping of +obj+'s visible attributes.
+    def self.serialize(obj, json_hash)
+      obj.instance_variables.each do |m|
+        key = m.to_s[/[^\@]\w*/].to_sym
+
+        next unless key && !key.eql?('')
+
+        begin
+          val = obj.send(key) # assuming readable attributes . . .
+        rescue NoMethodError # . . . which may not be always be the case !
+          json_hash[key] = nil
+        end
+
+        begin
+          # process class members of Hash type
+          if val.instance_of?(Hash)
+            nested_key = ''
+            nested = nil
+
+            val.each.any? do |k, v|
+              if v.instance_variables.first
+                nested_key = k
+                nested = v
+              end
+            end
+
+            json_hash[key] = val
+
+            if nested
+              pos = val.keys.select { |k| k === nested_key }.first.to_sym
+              nested.instance_variables.each do
+                json_hash[key][pos] = serialize(nested, class: nested.class.name)
+              end
+            end
+
+          # process class members of Array type
+          elsif val.instance_of?(Array)
+            json_hash[key] = []
+
+            val.each do |elem|
+              i = val.index(elem)
+
+              # multi-dimensional array
+              if elem.instance_of?(Array)
+                nested = []
+                elem.each do |e|
+                  j = elem.index(e)
+
+                  # nested array element is a class object
+                  if e.instance_variables.first
+                    json_hash[key][j] = { class: e.class.name }
+
+                    # recur over the contained object
+                    serialize(e, json_hash[key][j])
+                  else
+                    # some kind of collection?
+                    if e.respond_to? :each
+                      temp = []
+                      e.each { |el| temp << el }
+                      nested << temp
+                    else nested << e
+                    end
+                  end
+                end
+                # ~iteration of nested array elements
+
+                json_hash[key] << nested
+
+              else
+                # 1-D array of class objects
+                if elem.instance_variables.first
+                  json_hash[key] << { class: elem.class.name }
+                  serialize(elem, json_hash[key][i])
+                else
+                  # element of primitive type (or Array, or Hash):
+                  # leverage 1:1 mapping of Hash:object
+                  if elem.instance_of?(Hash) then json_hash[key] = val
+                  else
+                    # some kind of collection
+                    if elem.respond_to? :each
+                      temp = []
+                      elem.each { |e| temp << e }
+                      json_hash[key] << temp
+                    else json_hash[key] << elem
+                    end
+                  end
+                end
+              end
+            end
+          # ~iteration of top-level array elements
+
+          # process any nested class members, i.e., handle a recursive call
+          # to Serializer.serialize
+          elsif obj.index(val) || json_hash.key?(key)
+            if val.instance_variables.first
+              class_elem = { class: val.class.name }
+              json_hash[key] << class_elem
+              k = json_hash[key].index(class_elem)
+              serialize(val, json_hash[key][k])
+            else
+              json_hash[key] << val
+            end
+
+          # process uncollected data members
+          else
+            # member a class object
+            if val.instance_variables.first
+              json_hash[key] = { class: val.class.name }
+              serialize(val, json_hash[key])
+            else
+              # member a hash element
+              if json_hash.key?(key) && \
+                 !json_hash[key].has_val?(val) && \
+                 json_hash[key].instance_of?(Hash)
+
+                json_hash[key][key] = val
+              else
+                json_hash[key] = val
+              end
+            end
+          end
+        rescue NoMethodError
+          # we expected an array to behave like a hash, or vice-versa
+          json_hash.store(key, val) # a shallow copy is better than nothing
+        end
+      end
+      # ~iteration of instance variables
+
+      json_hash
+    end
+    # ~Serializer.serialize
+
+    ##
+    # Returns the given +node+ as pretty-printed JSON.
+    #
+    # @param node [#to_s] A visible attribute of +obj+.
+    # @param obj [{Object => Object}, <Object>] The enumerable object containing +node+.
+    # @return [String] A formatted string representation of +node+.
+    def self.format_node(node, obj)
+      str = ''
+
+      if node.instance_of?(Array)
+        str << "\n\t[\n"
+
+        node.each do |elem|
+          if elem.instance_of?(Hash)
+            str << "\t\t{\n"
+
+            elem.each_with_index do |inner_h, h_idx|
+              str << "\t\t\t\"#{inner_h.first}\":"
+              str << node_to_str(inner_h.last)
+              str << ', ' unless h_idx == (elem.to_a.length - 1)
+              str << "\n"
+            end
+
+            str << "\t\t}"
+            str << ',' unless node.index(elem) == (node.length - 1)
+            str << "\n" unless node.index(elem) == (node.length - 1)
+
+          else
+
+            if elem.instance_of?(Array) && elem.any? { |e| e.instance_of?(Array) }
+              @margins_to_backspace = elem.take_while { |e| e.instance_of?(Array) }.size
+            end
+
+            str << "\t\t"
+            str << node_to_str(elem)
+            str << ",\n" unless node.index(elem) == (node.length - 1)
+          end
+        end
+
+        str << "\n\t]\n"
+
+      elsif node.instance_of?(Hash)
+        str << "\n\t{\n"
+
+        node.each_with_index do |h, idx|
+          if h.last.instance_of?(Hash)
+            key = if h.first.eql? ''
+                    "\t\t\"<##{h.last.class.name.downcase}>\":"
+                  else
+                    "\t\t\"#{h.first}\":"
+                  end
+            str << key
+            str << "\n\t\t\t{\n"
+
+            h.last.each_with_index do |inner_h, inner_h_idx|
+              str << "\t\t\t\t\"#{inner_h.first}\":"
+              str << node_to_str(inner_h.last, 4)
+              str << ",\n" unless inner_h_idx == (h.last.to_a.length - 1)
+            end
+
+            str << "\n\t\t\t}"
+          else
+            str << "\t\t\"#{h.first}\": "
+            str << node_to_str(h.last)
+          end
+
+          str << ",\n" unless idx == (node.to_a.length - 1)
+        end
+
+        str << "\n\t}"
+        str << ', ' unless (obj.length <= 1) || \
+                           ((obj.length > 1) && \
+                           (obj.instance_of?(Hash) && \
+                             (obj.key(obj.values.last) === obj.key(node))) || \
+                           (obj.instance_of?(Array) && (obj.last == node)))
+        str << "\n"
+
+      else
+        str << node_to_str(node)
+        str << ', ' unless (obj.length <= 1) || \
+                           ((obj.length > 1) && \
+                           (obj.instance_of?(Hash) && \
+                             (obj.key(obj.values.last) === obj.key(node))) || \
+                           (obj.instance_of?(Array) && (obj.last === node)))
+        str << "\n"
+      end
+
+      str.gsub(/\t+[\n\r]+/, '').gsub(/\}\,+/, '},').gsub(/\]\,+/, '],')
+    end
+    # ~Serializer.format_node
+
+    ##
+    # Returns a JSON-appropriate string representation of +node+.
+    #
+    # @param node [#to_s] A visible attribute of a Ruby object.
+    # @param tabs [Fixnum] Tab width at which to start printing this node.
+    # @return [String] A formatted string representation of +node+.
+    def self.node_to_str(node, tabs = 0)
+      graft = ''
+
+      tabs += 2 if tabs.zero?
+      if @should_backspace
+        tabs -= 1
+        @margins_to_backspace -= 1
+      end
+
+      if node.nil? then graft << 'null'
+      elsif node.instance_of?(Hash)
+
+        format_node(node, node).scan(/.*$/) do |n|
+          graft << "\n" << ("\t" * tabs).to_s << n
+        end
+
+      elsif node.instance_of?(Array)
+        @should_backspace = @margins_to_backspace.positive?
+
+        format_node(node, {}).scan(/.*$/) do |n|
+          graft << "\n" << ("\t" * tabs).to_s << n
+        end
+
+      elsif !node.instance_of?(String) then graft << node.to_s
+      else graft << "\"#{node.gsub(/\"/, '\\"')}\""
+      end
+
+      graft.rstrip
+    end
+    # ~Serializer.node_to_str
+  end
+  # ~Serializer
+
+  private_constant :Serializer
+end
+# ~TidyJson
+
+##
+# Exposes the +TidyJson+ mixin to all Ruby objects.
+# ====
+#  class Object
+#    include TidyJson
+#  end
+class Object
+  include TidyJson
+end

data/test/test_tidy_json.rb

@@ -0,0 +1,49 @@
+require 'minitest/autorun'
+require 'tidy_json'
+
+##
+# Tests.
+#
+class JsonableObject
+  attr_reader(:h, :a)
+
+  def initialize
+    @h = { one: 'uno', two: 'dos', three: %w[eine zwei drei], cuatro: ['I', 'II', 'III', ['i.', 'ii.', 'iii.', 'iv.']] }
+    @a = ['k', 'l', %w[M N O P], 'q', 'r', 's', [10, 456, ['<abbr title="Reel 2, Dialog Track 2">R2D2</abbr>', 'R', 2, 'D', ['two']]], 'u', 'v', 'x', 'y', %w[Z AB]]
+  end
+end
+
+class TidyJsonTest < Minitest::Test
+  @@t = JsonableObject.new
+  @@t2 = JsonableObject.new
+  @@t3 = JsonableObject.new
+  @@t.h[:cinque] = { 'ichi' => "\u{4e00}", 'ni' => "\u{4e8c}", 'san' => "\u{4e09}", 'yon' => "\u{56db}" }
+  @@t.h[:sei] = @@t2
+  @@t2.h[:five] = @@t3
+  @@t.a.unshift([@@t2, 13, 14, 15, 5.6])
+
+  def test_version_number
+    refute_nil ::TidyJson::VERSION
+  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)
+  end
+
+  def test_tidy_instance
+    assert_equal({}.to_tidy_json, "{\n}\n")
+    assert_equal(JsonableObject.new.to_tidy_json.length, 568)
+  end
+
+  def test_stringify_instance
+    assert_equal(@@t.stringify, "{\"class\":\"JsonableObject\",\"h\":{\"one\":\"uno\",\"two\":\"dos\",\"three\":[\"eine\",\"zwei\",\"drei\"],\"cuatro\":[\"I\",\"II\",\"III\",[\"i.\",\"ii.\",\"iii.\",\"iv.\"]],\"cinque\":{\"ichi\":\"\u{4e00}\",\"ni\":\"\u{4e8c}\",\"san\":\"\u{4e09}\",\"yon\":\"\u{56db}\"},\"sei\":{\"class\":\"JsonableObject\",\"h\":{\"one\":\"uno\",\"two\":\"dos\",\"three\":[\"eine\",\"zwei\",\"drei\"],\"cuatro\":[\"I\",\"II\",\"III\",[\"i.\",\"ii.\",\"iii.\",\"iv.\"]],\"five\":{\"class\":\"JsonableObject\",\"h\":{\"one\":\"uno\",\"two\":\"dos\",\"three\":[\"eine\",\"zwei\",\"drei\"],\"cuatro\":[\"I\",\"II\",\"III\",[\"i.\",\"ii.\",\"iii.\",\"iv.\"]]},\"a\":[\"k\",\"l\",[\"M\",\"N\",\"O\",\"P\"],\"q\",\"r\",\"s\",[10,456,[\"<abbr title=\\\"Reel 2, Dialog Track 2\\\">R2D2</abbr>\",\"R\",2,\"D\",[\"two\"]]],\"u\",\"v\",\"x\",\"y\",[\"Z\",\"AB\"]]}},\"a\":[\"k\",\"l\",[\"M\",\"N\",\"O\",\"P\"],\"q\",\"r\",\"s\",[10,456,[\"<abbr title=\\\"Reel 2, Dialog Track 2\\\">R2D2</abbr>\",\"R\",2,\"D\",[\"two\"]]],\"u\",\"v\",\"x\",\"y\",[\"Z\",\"AB\"]]}},\"a\":[{\"class\":\"JsonableObject\",\"h\":{\"one\":\"uno\",\"two\":\"dos\",\"three\":[\"eine\",\"zwei\",\"drei\"],\"cuatro\":[\"I\",\"II\",\"III\",[\"i.\",\"ii.\",\"iii.\",\"iv.\"]],\"five\":{\"class\":\"JsonableObject\",\"h\":{\"one\":\"uno\",\"two\":\"dos\",\"three\":[\"eine\",\"zwei\",\"drei\"],\"cuatro\":[\"I\",\"II\",\"III\",[\"i.\",\"ii.\",\"iii.\",\"iv.\"]]},\"a\":[\"k\",\"l\",[\"M\",\"N\",\"O\",\"P\"],\"q\",\"r\",\"s\",[10,456,[\"<abbr title=\\\"Reel 2, Dialog Track 2\\\">R2D2</abbr>\",\"R\",2,\"D\",[\"two\"]]],\"u\",\"v\",\"x\",\"y\",[\"Z\",\"AB\"]]}},\"a\":[\"k\",\"l\",[\"M\",\"N\",\"O\",\"P\"],\"q\",\"r\",\"s\",[10,456,[\"<abbr title=\\\"Reel 2, Dialog Track 2\\\">R2D2</abbr>\",\"R\",2,\"D\",[\"two\"]]],\"u\",\"v\",\"x\",\"y\",[\"Z\",\"AB\"]]},[13,14,15,5.6],\"k\",\"l\",[\"M\",\"N\",\"O\",\"P\"],\"q\",\"r\",\"s\",[10,456,[\"<abbr title=\\\"Reel 2, Dialog Track 2\\\">R2D2</abbr>\",\"R\",2,\"D\",[\"two\"]]],\"u\",\"v\",\"x\",\"y\",[\"Z\",\"AB\"]]}")
+  end
+
+  def test_writers
+    output = @@t.write_json(false)
+    assert(File.exist?(output))
+    pretty_output = @@t.write_json(true, 'prettified')
+    assert(File.exist?(pretty_output))
+  end
+end

data/tidy_json.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/tidy_json/version'
+require_relative 'lib/tidy_json/dedication'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'tidy_json'
+  spec.version     = TidyJson::VERSION
+  spec.date        = Time.now.to_s[0..9].to_s
+  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.homepage    = 'https://github.com/rdipardo/tidy_json'
+  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)/) })
+  end
+  spec.test_files = Dir['test/*']
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+  spec.add_runtime_dependency 'json', '~> 2.2'
+  spec.add_development_dependency 'bundler', '~> 2.1'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'yard', '~> 0.9'
+  spec.rdoc_options = ['-x test/*']
+  spec.post_install_message = TidyJson::DEDICATION
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: tidy_json
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Robert Di Pardo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: A mixin providing (recursive) JSON serialization and pretty printing.
+email: rdipardo0520@conestogac.on.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/tidy_json.rb
+- lib/tidy_json/dedication.rb
+- lib/tidy_json/version.rb
+- test/test_tidy_json.rb
+- tidy_json.gemspec
+homepage: https://github.com/rdipardo/tidy_json
+licenses:
+- MIT
+metadata: {}
+post_install_message: |
+  ..................................................
+  .................... tidy_json ...................
+  ............ (c) 2019 Robert Di Pardo ............
+  ..................................................
+  ................... IN MEMORIAM ..................
+  ................ Michael Di Pardo ................
+  ................... 1950 - 2019 ..................
+  ..................................................
+  ............ Please consider supporting ...........
+  ............. the MS Society of Canada ...........
+  ........ https://mssociety.ca/get-involved .......
+  ..................................................
+rdoc_options:
+- "-x test/*"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.1
+signing_key: 
+specification_version: 4
+summary: Serialize any Ruby object as readable JSON
+test_files:
+- test/test_tidy_json.rb