diff_json 0.1.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1efd6e578e9220d1e84dda6873ced3b68193cc011340b66bbe4f6d56e70d3546
-  data.tar.gz: b210baa07705c2afb116ba528ace5ab8dcc3b07c8246f2eb386d45e7794fa065
+  metadata.gz: 5c3cd1f5a10a3800d0ff8cba80743be56fac546eebf7c22023f93a6f40b658b6
+  data.tar.gz: 06c2a5f2935d7023d7b86c7249c6df642f90857b47b2aada9ee43c0124ab41c9
 SHA512:
-  metadata.gz: 13dc56cb5ab81386c536d459e2e94a7ca967802b76f68353be95d9238a1d328fd03b87e3f1e01aa1950847c6a50418f8d55c04858c3fbc3b54962343e200858a
-  data.tar.gz: 47ac22e84aeac9b32d72c2e62db97654b0c13ada095d7f095bc506935ade353bc96634bd68a1f6f2397dfe002f39a7b7ef94796e4668cf1ff0b8eb8db44bfa62
+  metadata.gz: 238428418dc783d66c171f530ba4bc7b4584e9ce0a59d3e52ee1ab77d8009d7dce06d2a74a29003cbabd1865adac02afe896a122502ea0e1db3a9fb42d3fb7aa
+  data.tar.gz: 77e5dab6ee29e02312cc37c82b7558007df74085738f2f7e534a8814841d4a47537f18cc80b92cd1212e2439590276eaaf7aabe71513d87a4021b718f126c1ed

data/lib/diff_json.rb

@@ -1,5 +1,4 @@
 require 'json'
-
-require_relative './diff_json/undefined_value'
+require 'require_all'
 require_relative './diff_json/diff'
-require_relative './diff_json/html_output'
+require_rel './diff_json/output'

data/lib/diff_json/diff.rb

@@ -1,506 +1,78 @@
-module DiffJson
-  class Diff
-    def initialize(old_json, new_json, **opts)
-      @old_json   = old_json
-      @new_json   = new_json
-      @opts       = {
-        :debug              => false,
-        :diff_count_filter  => {
-          :only   => ['$**'],
-          :except => []
-        },
-        :ignore_object_keys        => [],
-        :generate_object_sub_diffs => {}
-      }.merge(opts)
-      @filtered = @opts[:diff_count_filter] != {
-        :only   => ['$**'],
-        :except => []
-      }
-      @diff = {
-        :count => {
-          :all    => 0,
-          :insert => 0,
-          :update => 0,
-          :delete => 0,
-          :move   => 0
-        },
-        :full_diff => {
-          :old   => [],
-          :new   => []
-        },
-        :sub_diffs => {}
-      }
-
-      calculate
-    end
-
-    def diff
-      return @diff[:full_diff]
-    end
-
-    def sub_diffs
-      return @diff[:sub_diffs]
-    end
-
-    def change_count(operation = :all)
-      return @diff[:count][operation] || 0
-    end
-
-    def retrieve_output(output_type = :stdout, **output_opts)
-      case output_type
-      when :stdout
-      when :file
-      when :html
-        html_output = HtmlOutput.new(self, **output_opts)
-        return html_output
-      end
-    end
-
-    private
-
-    def calculate
-      @diff[:full_diff][:old], @diff[:full_diff][:new] = compare_elements(@old_json, @new_json)
-
-      @diff[:sub_diffs].each do |key, sub_diffs|
-        sub_diffs.each do |value, diff|
-          diff[:old] = [] unless diff.key?(:old)
-          diff[:new] = [] unless diff.key?(:new)
-
-          diff[:old], diff[:new] = add_blank_lines(diff[:old], diff[:new])
-        end
-      end
-    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}"]}
+require_rel './diff'
 
-            (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
-
-        add_object_sub_diff_if_required(item_path, old_item, old_item_lines) if old_item.is_a?(Hash) and old_operator == '-'
-        add_object_sub_diff_if_required(item_path, new_item, new_item_lines, :new) if new_item.is_a?(Hash) and new_operator == '+'
-
-        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 = "#{JSON.pretty_generate(k, max_nesting: false, quirks_mode: true)}: "
-        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)}}"]
-
-      add_object_sub_diff_if_required(base_path, old_object, old_object_lines)
-      add_object_sub_diff_if_required(base_path, new_object, new_object_lines, :new)
-
-      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
+module DiffJson
+  def self.diff(old_json, new_json, return_type, diff_opts = {}, output_opts = {})
+    completed_diff = Diff.new(old_json, new_json, **diff_opts)
 
-      return indices
+    return case return_type
+    when :raw
+      completed_diff
+    when :html
+      HtmlOutput.new(completed_diff, **output_opts)
     end
+  end
 
-    def is_json_element?(object)
-      return true if ['array', 'object'].include?(value_type(object))
-    end
+  class Diff
+    include JsonMapping
+    include JsonDiffing
 
-    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
+    def initialize(old_json, new_json, **opts)
+      # Set config options
+      @opts = {
+        count_operations: {
+          '/**' => [:add, :replace, :remove, :move, :update]
+        },
+        ignore_paths: [],
+        path_sort: :sorted,
+        sub_diffs: {},
+        track_array_moves: true,
+        track_structure_updates: false
+      }.merge(opts)
+      # Create map of both JSON objects
+      @old_map = map_json(old_json, '', 0)
+      @new_map = map_json(new_json, '', 0)
+      # Gather the full list of all paths in both JSON objects in a consistent order
+      @all_paths = gather_paths(@old_map.keys, @new_map.keys, @opts[:path_sort] == :sorted)
+      # Generate diff operations list
+      @diff = diff_check(old_json, new_json)
+      # Find difference counts
+      @counts = find_counts(@diff)
+      # Gather sub-diffs
+      @sub_diffs = generate_sub_diffs
     end
 
-    def indentation(step)
-      step = 0 if step < 0
-      '  ' * step
+    def json_map(version = :old)
+      return (version == :old ? @old_map : @new_map)
     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
+    def diff
+      return @diff
     end
 
-    def increment_diff_count(path, operation)
-      unless @filtered
-        @diff[:count][operation] += 1
+    def paths(version = :joint)
+      return case version
+      when :old
+        json_map(:old).keys
+      when :new
+        json_map(:new).keys
       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) and
-          !@opts[:diff_count_filter][:only].empty?
-        )
-          @opts[:diff_count_filter][:only].each do |only_path|
-            unless ['none', 'lower'].include?(path_inclusion(path, only_path))
-              do_count = true
-              break
-            else
-              next
-            end
-          end
-        else
-          # If :only is empty or non-existent, count everything
-          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) and
-          !@opts[:diff_count_filter][:except].empty?
-        )
-          @opts[:diff_count_filter][:except].each do |except_path|
-            unless ['none', 'lower'].include?(path_inclusion(path, except_path))
-              do_count = false
-              break
-            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
-
-        debug("Post-operation, #{do_count}")
-
-        @diff[:count][:all]      += 1 if do_count
-        @diff[:count][operation] += 1 if do_count
+        @all_paths
       end
     end
 
-    def path_inclusion(current_path, check_path)
-      check_path_base     = check_path.gsub(/\*/, '')
-      check_path_wildcard = check_path.gsub(/[^\*]/, '') || ''
-      check               = 'lower'
-
-      if current_path == check_path_base
-        check = 'exact' if check_path_wildcard == ''
-        check = 'lower'
-      elsif current_path.include?(check_path_base)
-        current_path_remainder = current_path.gsub(check_path_base, '')
-        current_path_remainder_steps = current_path_remainder.split(/(\]\[|\]\{|\}\[|\}\{)/)
-
-        check = 'level'   if (current_path_remainder_steps.length == 1 and check_path_wildcard == '*')
-        check = 'recurse' if (current_path_remainder_steps.length > 0 and check_path_wildcard == '**')
+    def count(count_type = :all)
+      return case count_type
+      when :ignore, :add, :replace, :remove, :move, :update
+        @counts[count_type] || 0
+      when :total
+        @counts.values.sum
       else
-        check = 'none'
+        @counts
       end
-
-      return check
     end
 
-    def add_object_sub_diff_if_required(object_path, object, lines, side = :old)
-      if (
-        @opts.key?(:generate_object_sub_diffs) and
-        @opts[:generate_object_sub_diffs].is_a?(Hash) and
-        !@opts[:generate_object_sub_diffs].empty?
-      )
-        @opts[:generate_object_sub_diffs].each do |k,v|
-          unless ['none', 'lower'].include?(path_inclusion(object_path, k))
-            @diff[:sub_diffs][v] = {} unless @diff[:sub_diffs].key?(v)
-            @diff[:sub_diffs][v][object[v]] = {} unless @diff[:sub_diffs][v].key?(object[v])
-            @diff[:sub_diffs][v][object[v]][side] = lines if object.key?(v)
-          end
-        end
-      end
+    def sub_diffs
+      return @sub_diffs
     end
   end
 end

data/lib/diff_json/diff/json_diffing.rb

@@ -0,0 +1,193 @@
+module JsonDiffing
+  private
+
+  def diff_check(old_element, new_element, base_path = '')
+    diff_operations = {}
+
+    if (old_element.is_a?(Array) and new_element.is_a?(Array)) or (old_element.is_a?(Hash) and new_element.is_a?(Hash))
+      element_operations = case old_element.class.name
+      when 'Array'
+        diff_array(old_element, new_element, base_path)
+      when 'Hash'
+        diff_hash(old_element, new_element, base_path)
+      end
+
+      if @opts[:track_structure_updates]
+        element_operations[base_path] = [{op: :update}] if element_operations.select{|k,v| count_path?(k, "#{base_path}/*")}.length > 0
+      end
+
+      diff_operations.merge!(element_operations)
+    else
+      diff_operations[base_path] = [{op: :replace, path: base_path, value: new_element}] unless old_element == new_element
+    end
+
+    return diff_operations
+  end
+
+  def diff_array(old_array, new_array, base_path)
+    return {} if old_array == new_array
+
+    diff_operations = {}
+    add_drop_operations = {}
+    last_shared_index = (old_array.length - 1)
+
+    if @opts[:track_array_moves]
+      old_array_map   = old_array.each_with_index.map{|v,i| [i, v]}
+      new_array_map   = new_array.each_with_index.map{|v,i| [i, v]}
+      shared_elements = (old_array_map & new_array_map)
+      old_move_check  = (old_array_map - shared_elements)
+      new_move_check  = (new_array_map - shared_elements)
+      possible_moves  = []
+      max_moves       = (old_move_check.length < new_move_check.length ? old_move_check.length : new_move_check.length)
+
+      if max_moves > 0
+        old_move_check.each do |omc|
+          destinations = new_move_check.map{|v| omc[1] == v[1] ? [(omc[0] - v[0]).abs, omc[0], v[0]] : nil}.compact.sort_by{|x| x[0]}
+          if !destinations.empty? and possible_moves.length < max_moves
+            possible_moves << {op: :move, from: "#{base_path}/#{destinations.first[1]}", path: "#{base_path}/#{destinations.first[2]}"}
+          end
+        end
+      end
+    end
+
+    if new_array.length > old_array.length
+      new_array[(old_array.length)..(new_array.length - 1)].each_with_index do |value, i|
+        element_path = "#{base_path}/#{(old_array.length + i)}"
+        add_drop_operations[element_path] = [{op: :add, path: element_path, value: value}]
+
+        if @opts[:track_array_moves]
+          element_move_search = possible_moves.select{|x| x[:path] == element_path}
+          add_drop_operations[element_path] += element_move_search
+        end
+      end
+    elsif old_array.length > new_array.length
+      last_shared_index = new_array.length - 1
+
+      old_array[(new_array.length)..(old_array.length - 1)].each_with_index do |value, i|
+        element_path = "#{base_path}/#{(old_array.length + i)}"
+        add_drop_operations[element_path] = [{op: :remove, path: element_path}]
+
+        if @opts[:track_array_moves]
+          element_move_search = possible_moves.select{|x| x[:from] == element_path}
+          add_drop_operations[element_path] += element_move_search
+        end
+      end
+    end
+
+    (0..last_shared_index).each do |i|
+      index_path = "#{base_path}/#{i}"
+
+      if @opts[:track_array_moves]
+        element_move_search = possible_moves.select{|x| x[:from] == index_path or x[:path] == index_path}
+        element_move_search << {op: :replace, path: index_path, value: new_array[i]} if element_move_search.length == 1
+        diff_operations.merge!(element_move_search.empty? ? diff_check(old_array[i], new_array[i], index_path) : {index_path => element_move_search})
+      else
+        unless @opts[:ignore_paths].include?(index_path)
+          diff_operations.merge!(diff_check(old_array[i], new_array[i], index_path))
+        else
+          diff_operations[index_path] = [{op: :ignore}]
+        end
+      end
+    end
+
+    diff_operations.merge!(add_drop_operations)
+
+    return diff_operations
+  end
+
+  def diff_hash(old_hash, new_hash, base_path)
+    return {} if old_hash == new_hash
+
+    diff_operations = {}
+    old_keys, new_keys = old_hash.keys, new_hash.keys
+    common_keys, added_keys, dropped_keys = (old_keys & new_keys), (new_keys - old_keys), (old_keys - new_keys)
+
+    common_keys.each do |ck|
+      element_path = "#{base_path}/#{ck}"
+
+      unless @opts[:ignore_paths].include?(element_path)
+        diff_operations.merge!(diff_check(old_hash[ck], new_hash[ck], element_path))
+      else
+        diff_operations[element_path] = [{op: :ignore}]
+      end
+    end
+
+    added_keys.each do |ak|
+      element_path = "#{base_path}/#{ak}"
+      diff_operations[element_path] = [{op: :add, path: element_path, value: new_hash[ak]}]
+    end
+
+    dropped_keys.each do |dk|
+      element_path = "#{base_path}/#{dk}"
+      diff_operations[element_path] = [{op: :remove, path: element_path}]
+    end
+
+    return diff_operations
+  end
+
+  def generate_sub_diffs
+    sub_diffs = {}
+
+    @opts[:sub_diffs].each do |k,v|
+      sub_diff_paths = @all_paths.select{|x| count_path?(x, k)}
+      old_elements = @old_map.select{|k,v| sub_diff_paths.include?(k)}.values.map{|x| {x[:value][v[:key]] => x[:value]}}.reduce(:merge)
+      new_elements = @new_map.select{|k,v| sub_diff_paths.include?(k)}.values.map{|x| {x[:value][v[:key]] => x[:value]}}.reduce(:merge)
+
+      (old_elements.keys + new_elements.keys).uniq.each do |sub_diff_id|
+        sub_diffs["#{k}::#{sub_diff_id}"] = DiffJson::Diff.new((old_elements[sub_diff_id] || {}), (new_elements[sub_diff_id] || {}), **v[:opts]) unless old_elements[sub_diff_id] == new_elements[sub_diff_id]
+      end
+    end
+
+    return sub_diffs
+  end
+
+  def find_counts(diff_structure)
+    counts = {
+      ignore: 0,
+      add: 0,
+      replace: 0,
+      remove: 0
+    }
+    counts[:move]   = 0 if @opts[:track_array_moves]
+    counts[:update] = 0 if @opts[:track_structure_updates]
+
+    diff_structure.each do |path, operations|
+      inclusion = path_inclusion(path)
+
+      operations.each do |op|
+        counts[op[:op]] += 1 if (inclusion.include?(op[:op]) and ([:ignore, :add, :replace, :remove, :update].include?(op[:op]) or (op[:op] == :move and path == op[:from])))
+      end
+    end
+
+    return counts
+  end
+
+  def path_inclusion(path)
+    if @opts[:count_operations].include?('**')
+      return @opts[:count_operations]['**']
+    else
+      @opts[:count_operations].each do |path_set, operations|
+        return operations if count_path?(path, path_set)
+      end
+
+      return []
+    end
+  end
+
+  def count_path?(path, inclusion)
+    inclusion_base     = inclusion.gsub(/\/?\**$/, '')
+    inclusion_wildcard = /\**$/.match(inclusion)[0]
+
+    if path.include?(inclusion_base)
+      trailing_elements = path.gsub(/^#{inclusion_base}\/?/, '').split('/').length
+
+      return true if (
+        (trailing_elements == 0 and inclusion_wildcard == '') or
+        (trailing_elements == 1 and inclusion_wildcard == '*') or
+        (trailing_elements > 0 and inclusion_wildcard == '**')
+      )
+    end
+
+    return false
+  end
+end

data/lib/diff_json/diff/json_mapping.rb

@@ -0,0 +1,104 @@
+module JsonMapping
+  private
+
+  def path_indentation(path)
+    return 0 if path.empty?
+    return path.sub('/', '').split('/').length
+  end
+
+  def sortable_path(path)
+    return [''] if path.empty?
+    return path.split('/').map{|p| (p =~ /^\d+$/).nil? ? p : p.to_i}
+  end
+
+  def gather_paths(old_paths, new_paths, sort = false)
+    gathered_paths = []
+
+    if sort
+      sortable_paths = (old_paths | new_paths).map{|path| sortable_path(path)}
+
+      sortable_paths.sort! do |x,y|
+        last_index = x.length > y.length ? (x.length - 1) : (y.length - 1)
+        sort_value = nil
+
+        (0..last_index).each do |i|
+          next if x[i] == y[i]
+
+          sort_value = case [x[i].class.name, y[i].class.name]
+          when ['NilClass', 'Fixnum'], ['NilClass', 'Integer'], ['NilClass', 'String'], ['Fixnum', 'String'], ['Integer', 'String']
+            -1
+          when ['Fixnum', 'NilClass'], ['Integer', 'NilClass'], ['String', 'NilClass'], ['String', 'Fixnum'], ['String', 'Integer']
+            1
+          else
+            x[i] <=> y[i]
+          end
+
+          break unless sort_value.nil?
+        end
+
+        sort_value
+      end
+
+      return sortable_paths.map{|path| path.join('/')}
+    else
+      ### Implementation in progress, for now, raise error
+      raise 'Natural sort order is WIP, for now, do not override the :path_sort option'
+    end
+
+    return gathered_paths
+  end
+
+  def element_metadata(path, value, **overrides)
+    hash_list    = (value.is_a?(Array) ? value.map{|x| x.hash} : [])
+    is_structure = (value.is_a?(Array) or value.is_a?(Hash))
+
+    return {
+      :hash_list      => hash_list,
+      :indentation    => path_indentation(path),
+      :index          => 0,
+      :key            => nil,
+      :length         => (is_structure ? value.length : nil),
+      :trailing_comma => false,
+      :type           => (is_structure ? value.class.name.downcase.to_sym : :primitive),
+      :value          => value
+    }.merge(overrides)
+  end
+
+  def map_json(json, base_path, index, parent_length = 1, **metadata_overrides)
+    map            = {}
+    map[base_path] = element_metadata(base_path, json, index: index, trailing_comma: (index < (parent_length - 1)), **metadata_overrides)
+
+    if json.is_a?(Array)
+      json.each_with_index do |value, i|
+        index_path = "#{base_path}/#{i}"
+
+        if value.is_a?(Array)
+          map.merge!(map_json(value, index_path, i, value.length))
+        elsif value.is_a?(Hash)
+          map.merge!(map_json(value, index_path, i, value.keys.length))
+        else
+          map[index_path] = element_metadata(index_path, value, index: i, trailing_comma: (i < (json.length - 1)))
+        end
+      end
+    elsif json.is_a?(Hash)
+      json      = (@opts[:path_sort] == :sorted ? json.to_a.sort.to_h : json)
+      key_index = 0
+
+      json.each do |key, value|
+        key_path = "#{base_path}/#{key}"
+
+        if value.is_a?(Array)
+          map.merge!(map_json(value, key_path, key_index, value.length, key: key))
+        elsif value.is_a?(Hash)
+          map.merge!(map_json(value, key_path, key_index, value.keys.length, key: key))
+        else
+          map[key_path] = element_metadata(key_path, value, index: key_index, trailing_comma: (key_index < (json.keys.length - 1)), key: key)
+        end
+
+        key_index = key_index.next
+      end
+    end
+
+    return map
+  end
+end

data/lib/diff_json/output/html_output.rb

@@ -0,0 +1,268 @@
+module DiffJson
+  class HtmlOutput
+    def initialize(diff, **opts)
+      @diff = diff
+      @opts = {
+        table_id_prefix: 'diff_json_view_0',
+        markup_type: :bootstrap
+      }
+      @markup = build
+    end
+
+    def markup
+      return @markup
+    end
+
+    def diff
+      return @diff
+    end
+
+    private
+
+    def build
+      new_markup = {main: table_markup(@diff, @opts[:table_id_prefix]), sub_diffs: {}}
+
+      @diff.sub_diffs.each do |sdid, sub_diff|
+        new_markup[:sub_diffs][sdid] = HtmlOutput.new(sub_diff, @opts)
+      end
+
+      return new_markup
+    end
+
+    def table_markup(table_diff, table_id_prefix)
+      markup_lines = {left: "", right: "", full: "", sub_diffs: {}}
+
+      html_opener = self.method("html_#{@opts[:markup_type]}_opener".to_sym).call(table_id_prefix)
+      markup_lines[:left]  = html_opener[:left]
+      markup_lines[:right] = html_opener[:right]
+      markup_lines[:full]  = html_opener[:full]
+
+      hierarchy_lock = nil
+      structure_queue = []
+
+      table_diff.paths.each_with_index do |path, i|
+        skip_path = (!hierarchy_lock.nil? and !(path =~ /^#{hierarchy_lock}.+$/).nil?)
+        unless skip_path
+          if !hierarchy_lock.nil?
+            hierarchy_lock = nil
+          end
+
+          old_element, new_element = table_diff.json_map(:old)[path], table_diff.json_map(:new)[path]
+
+          operations = (table_diff.diff[path] || []).map{|op|
+            case op[:op]
+            when :ignore, :add, :replace, :remove
+              op[:op]
+            when :move
+              op[:from] == path ? :send_move : :receive_move
+            end
+          }.compact
+
+          if operations.empty? or operations.include?(:ignore)
+            left_operators = '  '
+            right_operators = '  '
+          else
+            left_operators = [operations.include?(:send_move) ? 'M' : ' ', (operations & [:replace, :remove]).length > 0 ? '-' : ' '].join
+            right_operators = [operations.include?(:receive_move) ? 'M' : ' ', (operations & [:add, :replace]).length > 0 ? '+' : ' '].join
+          end
+
+          if !old_element.nil? and !new_element.nil?
+            if (old_element[:value] == new_element[:value]) or (operations & [:ignore, :replace]).length > 0
+              old_lines, new_lines = balance_output(old_element[:value], new_element[:value], indentation: old_element[:indentation], old_key: old_element[:key], new_key: new_element[:key], old_comma: old_element[:trailing_comma], new_comma: new_element[:trailing_comma])
+              hierarchy_lock = path unless old_element[:type] == :primitive and new_element[:type] == :primitive
+            else
+              old_lines = jpg(nil, structure: true, structure_position: :open, structure_type: old_element[:type], indentation: old_element[:indentation], key: old_element[:key], trailing_comma: false)
+              new_lines = jpg(nil, structure: true, structure_position: :open, structure_type: new_element[:type], indentation: new_element[:indentation], key: new_element[:key], trailing_comma: false)
+              structure_queue.push({path: path, type: old_element[:type], indentation: old_element[:indentation], old_comma: old_element[:trailing_comma], new_comma: new_element[:trailing_comma]})
+            end
+          elsif old_element.nil?
+            old_lines, new_lines = balance_output(UndefinedValue.new, new_element[:value], indentation: new_element[:indentation], new_key: new_element[:key], new_comma: new_element[:trailing_comma])
+            hierarchy_lock = path unless new_element[:type] == :primitive
+          else
+            old_lines, new_lines = balance_output(old_element[:value], UndefinedValue.new, indentation: old_element[:indentation], old_key: old_element[:key], old_comma: old_element[:trailing_comma])
+            hierarchy_lock = path unless old_element[:type] == :primitive
+          end
+
+          compiled_lines = self.method("html_#{@opts[:markup_type]}_lines".to_sym).call(left_operators, old_lines, right_operators, new_lines)
+          markup_lines[:left] << compiled_lines[:left]
+          markup_lines[:right] << compiled_lines[:right]
+          markup_lines[:full] << compiled_lines[:full]
+        end
+
+        unless structure_queue.empty?
+          if i == (table_diff.paths.length - 1)
+            structure_queue.reverse.each do |sq|
+              old_lines = jpg(nil, structure: true, structure_position: :close, structure_type: sq[:type], indentation: sq[:indentation], trailing_comma: sq[:old_comma])
+              new_lines = jpg(nil, structure: true, structure_position: :close, structure_type: sq[:type], indentation: sq[:indentation], trailing_comma: sq[:new_comma])
+              compiled_lines = self.method("html_#{@opts[:markup_type]}_lines".to_sym).call('  ', old_lines, '  ', new_lines)
+              markup_lines[:left] << compiled_lines[:left]
+              markup_lines[:right] << compiled_lines[:right]
+              markup_lines[:full] << compiled_lines[:full]
+            end
+          else
+            if (table_diff.paths[(i+1)] =~ /^#{structure_queue.last[:path]}.+$/).nil?
+              sq = structure_queue.pop
+              old_lines = jpg(nil, structure: true, structure_position: :close, structure_type: sq[:type], indentation: sq[:indentation], trailing_comma: sq[:old_comma])
+              new_lines = jpg(nil, structure: true, structure_position: :close, structure_type: sq[:type], indentation: sq[:indentation], trailing_comma: sq[:new_comma])
+              compiled_lines = self.method("html_#{@opts[:markup_type]}_lines".to_sym).call('  ', old_lines, '  ', new_lines)
+              markup_lines[:left] << compiled_lines[:left]
+              markup_lines[:right] << compiled_lines[:right]
+              markup_lines[:full] << compiled_lines[:full]
+            end
+          end
+        end
+      end
+
+      html_closer = self.method("html_#{@opts[:markup_type]}_closer".to_sym).call
+      markup_lines[:left] << html_closer[:left]
+      markup_lines[:right] << html_closer[:right]
+      markup_lines[:full] << html_closer[:full]
+
+      return markup_lines
+    end
+
+    def html_table_opener(table_id_prefix)
+      compiled_lines = {}
+      compiled_lines[:left]  = "<table id=\"#{table_id_prefix}_left\" class=\"diff-json-view diff-json-split-view-left\">\n"
+      compiled_lines[:right] = "<table id=\"#{table_id_prefix}_right\" class=\"diff-json-view diff-json-split-view-right\">\n"
+      compiled_lines[:full]  = "<table id=\"#{table_id_prefix}_full\" class=\"diff-json-view diff-json-full-view\">\n"
+
+      return compiled_lines
+    end
+
+    def html_table_lines(left_operators, left_lines, right_operators, right_lines)
+      compiled_lines = {left: "", right: "", full: ""}
+
+      (0..(left_lines.length - 1)).each do |i|
+        compiled_lines[:left] << <<-EOL
+          <tr class="diff-json-view-line">
+            <td class="diff-json-view-line-operator"><pre>#{left_operators unless left_lines[i].empty?}</pre></td>
+            <td class="diff-json-view-line-content"><pre class="diff-json-line-breaker">#{left_lines[i]}</pre></td>
+          </tr>
+        EOL
+        compiled_lines[:right] << <<-EOL
+        <tr class="diff-json-view-line">
+          <td class="diff-json-view-line-operator"><pre>#{right_operators unless right_lines[i].empty?}</pre></td>
+          <td class="diff-json-view-line-content"><pre class="diff-json-line-breaker">#{right_lines[i]}</pre></td>
+        </tr>
+        EOL
+        compiled_lines[:full] << <<-EOL
+        <tr class="diff-json-view-line">
+          <div class="row">
+            <td class="diff-json-view-line-operator"><pre>#{left_operators unless left_lines[i].empty?}</pre></td>
+            <td class="diff-json-view-line-content"><pre class="diff-json-line-breaker">#{left_lines[i]}</pre></td>
+            <td class="diff-json-view-column-break"></td>
+            <td class="diff-json-view-line-operator"><pre>#{right_operators unless right_lines[i].empty?}</pre></td>
+            <td class="diff-json-view-line-content"><pre class="diff-json-line-breaker">#{right_lines[i]}</pre></td>
+          </div>
+        </tr>
+        EOL
+      end
+
+      return compiled_lines
+    end
+
+    def html_table_closer
+      compiled_lines = {}
+      compiled_lines[:left] = "</table>"
+      compiled_lines[:right] = "</table>"
+      compiled_lines[:full] = "</table>"
+
+      return compiled_lines
+    end
+
+    def html_bootstrap_opener(table_id_prefix)
+      compiled_lines = {}
+      compiled_lines[:left]  = "<div id=\"#{table_id_prefix}_left\" class=\"diff-json-view diff-json-split-view-left col-xs-6 col-6\">\n"
+      compiled_lines[:right] = "<div id=\"#{table_id_prefix}_right\" class=\"diff-json-view diff-json-split-view-right col-xs-6 col-6\">\n"
+      compiled_lines[:full]  = "<div id=\"#{table_id_prefix}_full\" class=\"diff-json-view diff-json-full-view col-xs-12 col-12\">\n"
+
+      return compiled_lines
+    end
+
+    def html_bootstrap_lines(left_operators, left_lines, right_operators, right_lines)
+      compiled_lines = {left: "", right: "", full: ""}
+
+      (0..(left_lines.length - 1)).each do |i|
+        compiled_lines[:left] << <<-EOL
+          <div class="diff-json-view-line row">
+            <div class="diff-json-view-line-operator col-xs-1"><pre>#{left_operators unless left_lines[i].empty?}</pre></div>
+            <div class="diff-json-view-line-content col-xs-11"><pre class="diff-json-line-breaker #{highlight_class(left_operators) unless left_lines[i].empty?}">#{left_lines[i]}</pre></div>
+          </div>
+        EOL
+        compiled_lines[:right] << <<-EOL
+        <div class="diff-json-view-line row">
+          <div class="diff-json-view-line-operator col-xs-1"><pre>#{right_operators unless right_lines[i].empty?}</pre></div>
+          <div class="diff-json-view-line-content col-xs-11"><pre class="diff-json-line-breaker #{highlight_class(right_operators) unless right_lines[i].empty?}">#{right_lines[i]}</pre></div>
+        </div>
+        EOL
+        compiled_lines[:full] << <<-EOL
+        <div class="diff-json-view-line row">
+          <div class="diff-json-view-line-left col-xs-6">
+            <pre class="diff-json-line-breaker #{highlight_class(left_operators) unless left_lines[i].empty?}">#{left_operators unless left_lines[i].empty?} #{left_lines[i]}</pre>
+          </div>
+          <div class="diff-json-view-line-right col-xs-6">
+            <pre class="diff-json-line-breaker #{highlight_class(right_operators) unless right_lines[i].empty?}">#{right_operators unless right_lines[i].empty?} #{right_lines[i]}</pre>
+          </div>
+        </div>
+        EOL
+      end
+
+      return compiled_lines
+    end
+
+    def html_bootstrap_closer
+      compiled_lines = {}
+      compiled_lines[:left] = "</div>"
+      compiled_lines[:right] = "</div>"
+      compiled_lines[:full] = "</div>"
+
+      return compiled_lines
+    end
+
+    def highlight_class(operators)
+      return '' if operators.empty?
+      return 'diff-json-content-ins' if operators.include?('+')
+      return 'diff-json-content-del' if operators.include?('-')
+      return 'diff-json-content-mov' if operators.include?('M')
+    end
+
+    def balance_output(old_element, new_element, indentation: 0, old_key: nil, new_key: nil, old_comma: false, new_comma: false)
+      old_lines, new_lines = jpg(old_element, indentation: indentation, key: old_key, trailing_comma: old_comma), jpg(new_element, indentation: indentation, key: new_key, trailing_comma: new_comma)
+      return old_lines, new_lines if old_lines.length == new_lines.length
+
+      if old_lines.length > new_lines.length
+        (old_lines.length - new_lines.length).times do
+          new_lines << ''
+        end
+      else
+        (new_lines.length - old_lines.length).times do
+          old_lines << ''
+        end
+      end
+
+      return old_lines, new_lines
+    end
+
+    def jpg(json_element, structure: false, structure_position: :open, structure_type: :array, indentation: 0, key: nil, trailing_comma: false)
+      return [] if json_element.is_a?(DiffJson::UndefinedValue)
+      if structure
+        generated_element = case [structure_position, structure_type]
+        when [:open, :array]
+          ['[']
+        when [:close, :array]
+          [']']
+        when [:open, :hash]
+          ['{']
+        when [:close, :hash]
+          ['}']
+        end
+      else
+        generated_element = JSON.pretty_generate(json_element, max_nesting: false, quirks_mode: true).lines
+      end
+      generated_element[0].prepend("#{key}: ") unless key.nil?
+      generated_element.last << ',' if trailing_comma
+      return generated_element.map{|line| line.prepend('  ' * indentation)}
+    end
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: diff_json
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Josh MacLachlan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-19 00:00:00.000000000 Z
-dependencies: []
+date: 2019-08-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 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
@@ -19,8 +33,10 @@ 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
+- lib/diff_json/diff/json_diffing.rb
+- lib/diff_json/diff/json_mapping.rb
+- lib/diff_json/output/html_output.rb
+- lib/diff_json/output/undefined_value.rb
 homepage: https://github.com/jtmaclachlan/diff_json
 licenses:
 - GPL-2

data/lib/diff_json/html_output.rb

@@ -1,98 +0,0 @@
-module DiffJson
-  class HtmlOutput
-
-    def initialize(diff, **opts)
-      @diff = diff
-      @opts = {
-        :table_id_prefix => 'diff_json_view_0'
-      }.merge(opts)
-      @output = {
-        :full_diff => {},
-        :sub_diffs => {}
-      }
-
-      calculate
-    end
-
-    def full
-      return @output[:full_diff][:full]
-    end
-
-    def left
-      return @output[:full_diff][:left]
-    end
-
-    def right
-      return @output[:full_diff][:right]
-    end
-
-    def sub_diffs
-      return @output[:sub_diffs]
-    end
-
-    private
-
-    def calculate
-      @output[:full_diff] = table_markup(@opts[:table_id_prefix], @diff.diff)
-
-      @diff.sub_diffs.each do |key, sub_diffs|
-        sub_diffs.each do |value, diff|
-          sub_key = "#{key}::#{value}"
-          table_key = "#{key}_#{value}"
-          @output[:sub_diffs][sub_key] = table_markup("#{@opts[:table_id_prefix]}_sub_diff_#{table_key}", diff)
-        end
-      end
-    end
-
-    def table_markup(table_id_prefix, lines)
-      markup = {
-        :full  => "",
-        :left  => "",
-        :right => ""
-      }
-
-      markup[:full]  = "<table id=\"#{table_id_prefix}_full\" class=\"diff-json-view diff-json-full-view\">\n"
-      markup[:left]  = "<table id=\"#{table_id_prefix}_left\" class=\"diff-json-view diff-json-split-view-left\">\n"
-      markup[:right] = "<table id=\"#{table_id_prefix}_right\" class=\"diff-json-view diff-json-split-view-right\">\n"
-
-      (0..(lines[:old].length - 1)).each do |i|
-        # Full, combined table output
-        markup[:full]  += "  <tr class=\"diff-json-view-line\">\n"
-        markup[:full]  += "    <td class=\"diff-json-view-line-operator\"><pre>#{lines[:old][i][0]}</pre></td>\n"
-        markup[:full]  += "    <td class=\"diff-json-view-line-content #{content_highlight_class(:left, lines[:old][i][0])}\"><pre>#{lines[:old][i][1]}</pre></td>\n"
-        markup[:full]  += "    <td class=\"diff-json-view-column-break\"></td>\n"
-        markup[:full]  += "    <td class=\"diff-json-view-line-operator\"><pre>#{lines[:new][i][0]}</pre></td>\n"
-        markup[:full]  += "    <td class=\"diff-json-view-line-content #{content_highlight_class(:right, lines[:new][i][0])}\"><pre>#{lines[:new][i][1]}</pre></td>\n"
-        markup[:full]  += "  </tr>\n"
-        # Split, left side output
-        markup[:left]  += "  <tr class=\"diff-json-view-line\">\n"
-        markup[:left]  += "    <td class=\"diff-json-view-line-operator\"><pre>#{lines[:old][i][0]}</pre></td>\n"
-        markup[:left]  += "    <td class=\"diff-json-view-line-content #{content_highlight_class(:left, lines[:old][i][0])}\"><pre>#{lines[:old][i][1]}</pre></td>\n"
-        markup[:left]  += "  </tr>\n"
-        # Split, right side output
-        markup[:right] += "  <tr class=\"diff-json-view-line\">\n"
-        markup[:right] += "    <td class=\"diff-json-view-line-operator\"><pre>#{lines[:new][i][0]}</pre></td>\n"
-        markup[:right] += "    <td class=\"diff-json-view-line-content #{content_highlight_class(:right, lines[:new][i][0])}\"><pre>#{lines[:new][i][1]}</pre></td>\n"
-        markup[:right] += "  </tr>\n"
-      end
-
-      markup[:full]  += "</table>\n"
-      markup[:left]  += "</table>\n"
-      markup[:right] += "</table>\n"
-
-      return markup
-    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 ''
-      end
-    end
-  end
-end