diff_json 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 500b28225357427a86dabd6853d94896a4efcaccb9e6f9e8153d2b93535ce183
+  data.tar.gz: de6dae135cebc7bb440239bf40a990c53c1849fc0fd0d2e26f867b083b231050
+SHA512:
+  metadata.gz: 8200a8a6996d6ab68ba6544d27172fd22e712aef12f9b6d62570084ca54e416cd495a4f13a73145532530609420b97540b80dbd89c772d95470df08d6dd80b75
+  data.tar.gz: 912663025aa950e5ded31559b2d3106592e58a44f23129421ed11320302e11caa2b274335ac03d7da2f67757fde3e6d03138bc8b420457370b2dc0fc8169d853

data/lib/diff_json/diff.rb

@@ -0,0 +1,460 @@
+module DiffJson
+  class Diff
+    def initialize(old_json, new_json, **opts)
+      @old_json   = old_json
+      @new_json   = new_json
+      @opts       = {
+        :debug              => false,
+        :ignore_object_keys => [],
+        :diff_count_filter  => {
+          :only   => ['$**'],
+          :except => []
+        }
+      }.merge(opts)
+      @filtered = @opts[:diff_count_filter] != {
+        :only   => ['$**'],
+        :except => []
+      }
+      @diff = {
+        :count => {
+          :all    => 0,
+          :insert => 0,
+          :update => 0,
+          :delete => 0,
+          :move   => 0
+        },
+        :old   => [],
+        :new   => []
+      }
+
+      calculate
+    end
+
+    def diff
+      return @diff
+    end
+
+    def retrieve_output(output_type = :stdout, **output_opts)
+      case output_type
+      when :stdout
+      when :file
+      when :html
+        html_output = HtmlOutput.new(@diff, **output_opts)
+        return html_output
+      end
+    end
+
+    private
+
+    def calculate
+      @diff[:old], @diff[:new] = compare_elements(@old_json, @new_json)
+      @calculated = true
+    end
+
+    def compare_elements(old_element, new_element, indent_step = 0, path = '$')
+      debug([
+        'ENTER compare_elements',
+        "Diffing #{path}"
+      ])
+
+      old_element_lines, new_element_lines = [], []
+
+      if old_element == new_element
+        debug('Equal elements, no diff required')
+
+        old_element_lines = JSON.pretty_generate(old_element, max_nesting: false, quirks_mode: true).split("\n").map{|el| [' ', "#{indentation(indent_step)}#{el}"]}
+        new_element_lines = JSON.pretty_generate(new_element, max_nesting: false, quirks_mode: true).split("\n").map{|el| [' ', "#{indentation(indent_step)}#{el}"]}
+      else
+        unless value_type(old_element) == value_type(new_element)
+          debug('Opposite type element, no diff required')
+
+          increment_diff_count(path, :insert)
+          increment_diff_count(path, :delete)
+          old_element_lines, new_element_lines = add_blank_lines(
+            JSON.pretty_generate(old_element, max_nesting: false, quirks_mode: true).split("\n").map{|el| ['-', "#{indentation(indent_step)}#{el}"]},
+            JSON.pretty_generate(new_element, max_nesting: false, quirks_mode: true).split("\n").map{|el| ['+', "#{indentation(indent_step)}#{el}"]}
+          )
+        else
+          debug("Found #{value_type(old_element)}, diffing")
+
+          increment_diff_count(path, :update)
+          old_element_lines, new_element_lines = self.send("#{value_type(old_element)}_diff", old_element, new_element, indent_step, path)
+        end
+      end
+
+      return old_element_lines, new_element_lines
+    end
+
+    def array_diff(old_array, new_array, indent_step, base_path)
+      debug('ENTER array_diff')
+
+      oal, nal   = old_array.length, new_array.length
+      sal        = oal < nal ? oal : nal
+      lal        = oal > nal ? oal : nal
+      old_array_lines, new_array_lines = [[' ', "#{indentation(indent_step)}["]], [[' ', "#{indentation(indent_step)}["]]
+      next_step = indent_step + 1
+      operations = {
+        'none'             => [],
+        'arr_add_index'    => [],
+        'arr_drop_index'   => [],
+        'arr_send_move'    => [],
+        'arr_receive_move' => []
+      }
+
+      # Find indices that were added or dropped, if any
+      if oal < nal
+        operations['arr_add_index'] += (oal..(nal - 1)).to_a
+      elsif oal > nal
+        operations['arr_drop_index'] += (nal..(oal - 1)).to_a
+      end
+
+      # Find 'none' and 'move_value' operations
+      (old_array | new_array).each do |v|
+        # For a given value, find all indices of each array that corresponds
+        old_indices, new_indices = array_indices(old_array, v), array_indices(new_array, v)
+        # Same index, same value, no diff necessary
+        operations['none'] += (old_indices & new_indices)
+
+        # Pull the skipped indices before calculating movements
+        old_indices -= operations['none']
+        new_indices -= operations['none']
+
+        # Find values that were moved from one index to another
+        if !old_indices.empty? and !new_indices.empty?
+          max_moves = old_indices.length < new_indices.length ? old_indices.length : new_indices.length
+          possible_moves = []
+          # Make pairs of possible moves
+          old_indices.each do |oi|
+            new_indices.each do |ni|
+              possible_moves << [(oi - ni).abs, [oi, ni]]
+            end
+          end
+          # For the sake of simplicity, we'll arbitrarily decide to use the shortest moves
+          possible_moves.sort!{|x,y| x[0] <=> y[0]}
+          # Take the first (max_moves) moves and add their operations
+          possible_moves[0..(max_moves - 1)].each do |move|
+            operations['arr_send_move'] << move[1][0]
+            operations['arr_receive_move'] << move[1][1]
+          end
+        end
+      end
+
+      # Add base diff for each index
+      (0..(lal - 1)).each do |i|
+        debug("PROCESS INDEX #{i}")
+
+        item_path = "#{base_path}[#{i}]"
+        old_item_lines, new_item_lines = [], []
+        item_diff_operations = []
+        last_loop = (i == (lal - 1))
+
+        # Assign current known operations to each index
+        (operations.keys).each do |operation|
+          if operations[operation].include?(i)
+            item_diff_operations << operation
+          end
+        end
+
+        # Add arr_change_value, arr_add_value, and arr_drop_value operations
+        if item_diff_operations.empty?
+          item_diff_operations << 'arr_change_value'
+        elsif (
+          item_diff_operations.include?('arr_send_move') and
+          !item_diff_operations.include?('arr_receive_move') and
+          !item_diff_operations.include?('arr_drop_index')
+        )
+          item_diff_operations << 'arr_add_value'
+        elsif (
+          !item_diff_operations.include?('arr_send_move') and
+          item_diff_operations.include?('arr_receive_move') and
+          !item_diff_operations.include?('arr_add_index')
+        )
+          item_diff_operations << 'arr_drop_value'
+        end
+
+        # Call compare_elements for sub-elements if necessary
+        if (!(item_diff_operations & ['none', 'arr_change_value']).empty? and
+          is_json_element?(old_array[i]) and is_json_element?(new_array[i])
+        )
+          old_item_lines, new_item_lines = compare_elements(old_array[i], new_array[i], next_step, item_path)
+        else
+          # Grab old and new items
+          # UndefinedValue class is here to represent the difference between explicit null and non-existent
+          old_item = item_diff_operations.include?('arr_add_index') ? UndefinedValue.new : old_array[i]
+          new_item = item_diff_operations.include?('arr_drop_index') ? UndefinedValue.new : new_array[i]
+
+          # Figure out operators for left and right
+          if item_diff_operations.include?('none')
+            old_operator, new_operator = ' '
+          elsif item_diff_operations.include?('arr_change_value')
+            increment_diff_count(item_path, :update)
+            old_operator, new_operator = '-', '+'
+          elsif (item_diff_operations & ['arr_send_move', 'arr_receive_move']).length == 2
+            increment_diff_count(item_path, :move)
+            old_operator, new_operator = 'M', 'M'
+          elsif item_diff_operations.include?('arr_add_value')
+            increment_diff_count(item_path, :insert)
+            old_operator, new_operator = 'M', '+'
+          elsif item_diff_operations.include?('arr_drop_value')
+            increment_diff_count(item_path, :delete)
+            old_operator, new_operator = '-', 'M'
+          elsif item_diff_operations.include?('arr_drop_index')
+            if item_diff_operations.include?('arr_send_move')
+              increment_diff_count(item_path, :move)
+              old_operator, new_operator = 'M', ' '
+            else
+              increment_diff_count(item_path, :delete)
+              old_operator, new_operator = '-', ' '
+            end
+          elsif item_diff_operations.include?('arr_add_index')
+            if item_diff_operations.include?('arr_receive_move')
+              old_operator, new_operator = ' ', 'M'
+            else
+              increment_diff_count(item_path, :insert)
+              old_operator, new_operator = ' ', '+'
+            end
+          end
+
+          # Gather lines
+          if old_item.is_a?(UndefinedValue)
+            new_item_lines = JSON.pretty_generate(new_item, max_nesting: false, quirks_mode: true).split("\n").map{|il| [new_operator, "#{indentation(next_step)}#{il}"]}
+
+            (0..(new_item_lines.length - 1)).each do |i|
+              old_item_lines << [' ', '']
+            end
+          else
+            old_item_lines = JSON.pretty_generate(old_item, max_nesting: false, quirks_mode: true).split("\n").map{|il| [old_operator, "#{indentation(next_step)}#{il}"]}
+          end
+
+          if new_item.is_a?(UndefinedValue)
+            (0..(old_item_lines.length - 1)).each do |i|
+              new_item_lines << [' ', '']
+            end
+          else
+            new_item_lines = JSON.pretty_generate(new_item, max_nesting: false, quirks_mode: true).split("\n").map{|il| [new_operator, "#{indentation(next_step)}#{il}"]}
+          end
+        end
+
+        unless old_item_lines.empty?
+          old_item_lines.last[1] = "#{old_item_lines.last[1]}," if !last_loop and (old_item_lines.last[1].match(/[^\s]/))
+        end
+        unless new_item_lines.empty?
+          new_item_lines.last[1] = "#{new_item_lines.last[1]}," if !last_loop and (new_item_lines.last[1].match(/[^\s]/))
+        end
+
+        old_item_lines, new_item_lines = add_blank_lines(old_item_lines, new_item_lines)
+
+        old_array_lines += old_item_lines
+        new_array_lines += new_item_lines
+      end
+
+      old_array_lines << [' ', "#{indentation(indent_step)}]"]
+      new_array_lines << [' ', "#{indentation(indent_step)}]"]
+
+      return old_array_lines, new_array_lines
+    end
+
+    def object_diff(old_object, new_object, indent_step, base_path)
+      debug('ENTER object_diff')
+
+      keys = {
+        'all'    => (old_object.keys | new_object.keys),
+        'common' => (old_object.keys & new_object.keys),
+        'add'    => (new_object.keys - old_object.keys),
+        'drop'   => (old_object.keys - new_object.keys)
+      }
+      old_object_lines, new_object_lines = [[' ', "#{indentation(indent_step)}{"]], [[' ', "#{indentation(indent_step)}{"]]
+      next_step = indent_step + 1
+
+      # For objects, we're taking a much simpler approach, so no movements
+      keys['all'].each do |k|
+        debug("PROCESS KEY #{k}")
+
+        item_path = "#{base_path}{#{k}}"
+        key_string = "#{k}: "
+        old_item_lines, new_item_lines = [], []
+        last_loop = (k == keys['all'].last)
+
+        if keys['common'].include?(k)
+          if is_json_element?(old_object[k]) and is_json_element?(new_object[k]) and !@opts[:ignore_object_keys].include?(k)
+            old_item_lines, new_item_lines = compare_elements(old_object[k], new_object[k], next_step, item_path)
+          else
+            if old_object[k] == new_object[k] or @opts[:ignore_object_keys].include?(k)
+              old_item_lines = JSON.pretty_generate(old_object[k], max_nesting: false, quirks_mode: true).split("\n").map!{|il| [' ', "#{indentation(next_step)}#{il}"]}
+              new_item_lines = JSON.pretty_generate(new_object[k], max_nesting: false, quirks_mode: true).split("\n").map!{|il| [' ', "#{indentation(next_step)}#{il}"]}
+            else
+              increment_diff_count(item_path, :update)
+              old_item_lines = JSON.pretty_generate(old_object[k], max_nesting: false, quirks_mode: true).split("\n").map!{|il| ['-', "#{indentation(next_step)}#{il}"]}
+              new_item_lines = JSON.pretty_generate(new_object[k], max_nesting: false, quirks_mode: true).split("\n").map!{|il| ['+', "#{indentation(next_step)}#{il}"]}
+            end
+          end
+        else
+          if keys['drop'].include?(k)
+            increment_diff_count(item_path, :delete) unless @opts[:ignore_object_keys].include?(k)
+            old_item_lines = JSON.pretty_generate(old_object[k], max_nesting: false, quirks_mode: true).split("\n").map!{|il| [@opts[:ignore_object_keys].include?(k) ? ' ' : '-', "#{indentation(next_step)}#{il}"]}
+            new_item_lines = []
+
+            (0..(old_item_lines.length - 1)).each do |i|
+              new_item_lines << [' ', '']
+            end
+          elsif keys['add'].include?(k)
+            increment_diff_count(item_path, :insert) unless @opts[:ignore_object_keys].include?(k)
+            new_item_lines = JSON.pretty_generate(new_object[k], max_nesting: false, quirks_mode: true).split("\n").map!{|il| [@opts[:ignore_object_keys].include?(k) ? ' ' : '+', "#{indentation(next_step)}#{il}"]}
+            old_item_lines = []
+
+            (0..(new_item_lines.length - 1)).each do |i|
+              old_item_lines << [' ', '']
+            end
+          end
+        end
+
+        unless old_item_lines.empty?
+          old_item_lines[0][1].gsub!(/^(?<spaces>\s+)(?<content>.+)$/, "\\k<spaces>#{key_string}\\k<content>")
+          old_item_lines.last[1] = "#{old_item_lines.last[1]}," if !last_loop and (old_item_lines.last[1].match(/[^\s]/))
+        end
+        unless new_item_lines.empty?
+          new_item_lines[0][1].gsub!(/^(?<spaces>\s+)(?<content>.+)$/, "\\k<spaces>#{key_string}\\k<content>")
+          new_item_lines.last[1] = "#{new_item_lines.last[1]}," if !last_loop and (new_item_lines.last[1].match(/[^\s]/))
+        end
+
+        old_item_lines, new_item_lines = add_blank_lines(old_item_lines, new_item_lines)
+
+        old_object_lines += old_item_lines
+        new_object_lines += new_item_lines
+      end
+
+      old_object_lines << [' ', "#{indentation(indent_step)}}"]
+      new_object_lines << [' ', "#{indentation(indent_step)}}"]
+
+      return old_object_lines, new_object_lines
+    end
+
+    def debug(message)
+      puts message if @opts[:debug]
+    end
+
+    def array_indices(array, value)
+      indices = []
+
+      array.each_with_index do |av,i|
+        indices << i if av == value
+      end
+
+      return indices
+    end
+
+    def is_json_element?(object)
+      return true if ['array', 'object'].include?(value_type(object))
+    end
+
+    def value_type(element)
+      case class_name = element.class.name
+      when 'Hash'
+        return 'object'
+      when 'NilClass'
+        return 'null'
+      when 'TrueClass', 'FalseClass'
+        return 'boolean'
+      else
+        return class_name.downcase
+      end
+    end
+
+    def indentation(step)
+      step = 0 if step < 0
+      '  ' * step
+    end
+
+    def add_blank_lines(left_lines, right_lines)
+      if left_lines.length < right_lines.length
+        (1..(right_lines.length - left_lines.length)).each do
+          left_lines << [' ', '']
+        end
+      elsif left_lines.length > right_lines.length
+        (1..(left_lines.length - right_lines.length)).each do
+          right_lines << [' ', '']
+        end
+      end
+
+      return left_lines, right_lines
+    end
+
+    def increment_diff_count(path, operation)
+      unless @filtered
+        @diff[:count][operation] += 1
+      else
+        do_count = false
+
+        # Any path prefixes in `only` that match?
+        if (
+          @opts[:diff_count_filter].key?(:only) and
+          @opts[:diff_count_filter][:only].is_a?(Array)
+        )
+          @opts[:diff_count_filter][:only].each do |only_path|
+            only_path_prefix   = only_path.gsub(/\*/, '')
+            only_path_wildcard = only_path.gsub(/[^\*]/, '')
+
+            if path.include?(only_path_prefix)
+              path_remainder = path.gsub(only_path_prefix, '').split(/(\]\[|\]\{|\}\[|\}\{)/)
+
+              if (
+                (path_remainder.length == 0 and only_path_wildcard.length == 0) or
+                (path_remainder.length == 1 and only_path_wildcard.length > 0) or
+                (path_remainder.length > 1 and only_path_wildcard.length > 1)
+              )
+                do_count = true
+                break
+              end
+            else
+              next
+            end
+          end
+        else
+          do_count = true
+        end
+
+        # Make sure the specific path is not excluded, if we've established that we should probably include it
+        if (
+          do_count and
+          @opts[:diff_count_filter].key?(:except) and
+          @opts[:diff_count_filter][:except].is_a?(Array)
+        )
+          @opts[:diff_count_filter][:except].each do |except_path|
+            except_path_prefix   = except_path.gsub(/\*/, '')
+            except_path_wildcard = except_path.gsub(/[^\*]/, '') || ''
+
+            if path.include?(except_path_prefix)
+              path_remainder = path.gsub(except_path_prefix, '').split(/(\]\[|\]\{|\}\[|\}\{)/)
+
+              if (
+                (path_remainder.length == 0 and except_path_wildcard.length == 0) or
+                (path_remainder.length == 1 and except_path_wildcard.length > 0) or
+                (path_remainder.length > 1 and except_path_wildcard.length > 1)
+              )
+                do_count = false
+                break
+              end
+            else
+              next
+            end
+          end
+        end
+
+        # Ensure this operation is allowed for counting
+        if (
+          do_count and
+          @opts[:diff_count_filter].key?(:operations) and
+          @opts[:diff_count_filter][:operations].is_a?(Array)
+        )
+          do_count = false if (
+            !@opts[:diff_count_filter][:operations].empty? and
+            !@opts[:diff_count_filter][:operations].include?(operation)
+          )
+        end
+
+        @diff[:count][:all]      += 1 if do_count
+        @diff[:count][operation] += 1 if do_count
+      end
+    end
+  end
+end

data/lib/diff_json/html_output.rb

@@ -0,0 +1,80 @@
+module DiffJson
+  class HtmlOutput
+
+    def initialize(diff, **opts)
+      @diff = diff
+      @opts = {
+        :split    => false,
+        :table_id_prefix => 'diff_json_view_0'
+      }.merge(opts)
+
+      calculate
+    end
+
+    def output
+      return @output
+    end
+
+    def left
+      return @output[:left] if @opts[:split]
+
+      raise 'Method `#left` is only available for split output'
+    end
+
+    def right
+      return @output[:right] if @opts[:split]
+
+      raise 'Method `#right` is only available for split output'
+    end
+
+    private
+
+    def calculate
+      if @opts[:split]
+        @output = {
+          :left  => "<table id=\"#{@opts[:table_id_prefix]}_left\" class=\"diff-json-split-view-left\">\n",
+          :right => "<table id=\"#{@opts[:table_id_prefix]}_right\" class=\"diff-json-split-view-right\">\n"
+        }
+
+        (0..(@diff[:old].length - 1)).each do |i|
+          @output[:left]  += "<tr class=\"diff-json-view-line\">\n"
+          @output[:left]  += "<td class=\"diff-json-view-line-operator\">#{@diff[:old][i][0].gsub(/\s/, '&nbsp;')}</td>\n"
+          @output[:left]  += "<td class=\"diff-json-view-line-content #{content_highlight_class(:left, @diff[:old][i][0])}\">#{@diff[:old][i][1].gsub(/\s/, '&nbsp;')}</td>\n"
+          @output[:left]  += "</tr>\n"
+          @output[:right] += "<tr class=\"diff-json-view-line\">\n"
+          @output[:right] += "<td class=\"diff-json-view-line-operator\">#{@diff[:new][i][0].gsub(/\s/, '&nbsp;')}</td>\n"
+          @output[:right] += "<td class=\"diff-json-view-line-content #{content_highlight_class(:right, @diff[:new][i][0])}\">#{@diff[:new][i][1].gsub(/\s/, '&nbsp;')}</td>\n"
+          @output[:right] += "</tr>\n"
+        end
+
+        @output[:left]  += "</table>\n"
+        @output[:right] += "</table>\n"
+      else
+        @output = "<table id=\"#{@opts[:table_id_prefix]}_full\" class=\"diff-json-view\">\n"
+
+        (0..(@diff[:old].length - 1)).each do |i|
+          @output += "<tr class=\"diff-json-view-line\">\n"
+          @output += "<td class=\"diff-json-view-line-operator\">#{@diff[:old][i][0].gsub(/\s/, '&nbsp;')}</td>\n"
+          @output += "<td class=\"diff-json-view-line-content #{content_highlight_class(:left, @diff[:old][i][0])}\">#{@diff[:old][i][1].gsub(/\s/, '&nbsp;')}</td>\n"
+          @output += "<td class=\"diff-json-view-line-operator\">#{@diff[:new][i][0].gsub(/\s/, '&nbsp;')}</td>\n"
+          @output += "<td class=\"diff-json-view-line-content #{content_highlight_class(:right, @diff[:new][i][0])}\">#{@diff[:new][i][1].gsub(/\s/, '&nbsp;')}</td>\n"
+          @output += "</tr>\n"
+        end
+
+        @output += "</table>\n"
+      end
+    end
+
+    def content_highlight_class(side, operator)
+      if operator == '-'
+        return 'diff-json-content-del'
+      elsif operator == '+'
+        return 'diff-json-content-ins'
+      elsif operator == 'M'
+        return side == :left ? 'diff-json-content-del' : 'diff-json-content-ins'
+      else
+        return nil
+      end
+    end
+  end
+end

data/lib/diff_json/undefined_value.rb

@@ -0,0 +1,4 @@
+module DiffJson
+  class UndefinedValue
+  end
+end

data/lib/diff_json.rb

@@ -0,0 +1,5 @@
+require 'json'
+
+require_relative './diff_json/undefined_value'
+require_relative './diff_json/diff'
+require_relative './diff_json/html_output'

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: diff_json
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Josh MacLachlan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-13 00:00:00.000000000 Z
+dependencies: []
+description: Diffs two JSON objects and returns a left/right diff view, similar to
+  the command line `diff` utility
+email: josh.t.maclachlan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/diff_json.rb
+- lib/diff_json/diff.rb
+- lib/diff_json/html_output.rb
+- lib/diff_json/undefined_value.rb
+homepage: https://github.com/jtmaclachlan/diff_json
+licenses:
+- GPL-2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Diffs two JSON objects and returns a left/right diff view, similar to the
+  command line `diff` utility
+test_files: []