diff_json 0.1.2 → 1.1.0

data/lib/diff_json/diff/json_diffing.rb

@@ -0,0 +1,201 @@
+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, from: old_element, 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[:replace_primitives_arrays]
+      if @old_map[base_path][:array_type] == :primitives and @new_map[base_path][:array_type] == :primitives
+        diff_operations[base_path] = [{op: :replace, path: base_path, from: old_array, value: new_array}]
+        return diff_operations
+      end
+    end
+
+    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_index = (new_array.length + i)
+        element_path = "#{base_path}/#{element_index}"
+        add_drop_operations[element_path] = [{op: :remove, path: element_path, value: old_array[element_index]}]
+
+        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,122 @@
+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 is_structure?(value)
+    return (value.is_a?(Array) or value.is_a?(Hash))
+  end
+
+  def element_metadata(path, value, **overrides)
+    hash_list    = (value.is_a?(Array) ? value.map{|x| x.hash} : [])
+    is_structure = is_structure?(value)
+    array_type   = nil
+
+    if is_structure and value.is_a?(Array)
+      structure_detection = value.map{|v| is_structure?(v)}.uniq
+
+      array_type = if structure_detection.empty?
+        :empty
+      elsif structure_detection.length > 1
+        :mixed
+      else
+        (structure_detection.first ? :structures : :primitives)
+      end
+    end
+
+    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),
+      :array_type     => array_type,
+      :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 diff
+      return @diff
+    end
+
+    def markup
+      return @markup
+    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 or (operations & [:send_move, :receive_move]).length == 2
+              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