minitest-holdify 1.2.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 056a8cc8b2a69276cf8adc189965b484cb9742b6c4e71efaca3b194b56bc1965
-  data.tar.gz: 1570f826edd18de9ee3dbbe6fa39d759f597ab5f5f4ebf452b015ae9cc26f240
+  metadata.gz: aff615590c52a4b538a92ae7e90dd24a6d4f5461e70b3cc240f5a30a819a8855
+  data.tar.gz: 6a0977317a054b2e6c89c403715c2815cd3d24d479161f83c622acb55ded2aeb
 SHA512:
-  metadata.gz: c6caaf67f67c9992df20d00ab2fc498365ae09f13225e7469aa370b68f0a42cbb77c97c7e68825c21b42600a606ef4c468bcec011c54e2380945bb8f9394741f
-  data.tar.gz: 30bf7d38f0df80f1a2b581c12ee7fbd1ca6811369fe4a2977e286d1876d37daabb1eb5cd8b8d9b81ceb40103dcf430003ef1ed8240db79ce5c5579680395ca7b
+  metadata.gz: 8f0553c5e76cced33e96d49adf7b89929d2d119d3f375ac36ea1aa3fac2a5786cfc65000aaefae5bf5066f94921840549927761a36b2f9832f6ea770a8a71702
+  data.tar.gz: 73ff0933e454a35def50e40b2cf46b82a45a4fa801c6dbb2dcb9a36d4ef11ddd91ee51649260f60e544ef581e7768942076aa1a4120aae4aeabf5a4d4a65cb79

data/lib/holdify/feedback.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'tempfile'
+require 'open3'
+
+module Holdify
+  # Feedback report on failure
+  class Feedback
+    attr_reader :xxhi_ref
+
+    def initialize(hold, hold_ref, *args)
+      test_lno  = hold.test_loc.lineno
+      index     = hold.session[test_lno].size - 1   # current index
+      xxh       = hold.store.xxh(test_lno)
+      yaml_path = hold.store.path
+
+      @xxhi_ref = "<<< @xxh[i] --> #{xxh}[#{index}]"
+
+      @yaml_lno = find_yaml_lno(yaml_path, test_lno, xxh, index)
+      @yaml_ref = Holdify.relative("#{yaml_path}:#{@yaml_lno}")
+
+      @hold_ref = Holdify.relative(hold_ref)
+      test_ref  = Holdify.relative(hold.test_loc.to_s.sub(/:in .*$/, ''))
+      @test_ref = test_ref unless @hold_ref == test_ref
+
+      @expected, @actual, @message = *args
+
+      # Extend with features
+      extend(Color) if Holdify.color
+      return unless Holdify.git
+
+      extend GitDiff
+      extend(Color::GitDiff) if Holdify.color
+    end
+
+    def message = [@message, xxhi_ref, *file_refs, *diff, ''].join("\n")
+
+    def file_refs
+      ["--- @stored --> #{@yaml_ref}", "+++ @tested --> #{@hold_ref}"].tap do |refs|
+        refs << "            --> #{@test_ref}" if @test_ref
+      end
+    end
+
+    def diff = ["- #{@expected.inspect}", "+ #{@actual.inspect}"]
+
+    private
+
+    def find_yaml_lno(yaml_path, test_lno, xxh, index)
+      found = false
+      count = -1
+      File.foreach(yaml_path).with_index(1) do |line, ln|
+        if found
+          next unless line.start_with?('-')
+
+          count += 1
+          next unless count == index
+
+          return ln
+        else
+          found = line.match(/^L#{test_lno} #{xxh}:$/)
+        end
+      end
+    end
+
+    # Methods enabling the git-diff feedback (no-color)
+    module GitDiff
+      def git_command = "git diff --no-index --no-color --unified=1000 #{@exp_path} #{@act_path}"
+
+      def diff
+        @exp_path = create_tempfile(@expected, 'expected').path
+        @act_path = create_tempfile(@actual, 'actual').path
+
+        stdout, = Open3.capture3(git_command)
+        regex   = /\A[^@]*\r?\n/m   # cleanup git headers
+        lines   = stdout.sub(regex, '').split(/\r?\n/)
+
+        process_lines(lines)
+      ensure
+        # :nocov:
+        File.unlink(@exp_path) if @exp_path
+        File.unlink(@act_path) if @act_path
+        # :nocov:
+      end
+
+      def create_tempfile(obj, type)
+        Tempfile.create.tap do |file|
+          file.write(Store.hold_dump(obj).sub(/(?=\n)/, type))
+          file.close
+        end
+      end
+
+      def process_lines(lines)
+        width  = 0
+        lineno = [@yaml_lno - 1]
+        lines.map.with_index do |line, i|
+          if i.zero? # @@ ... @@
+            width, line = render_hunk(line)
+            next line
+          end
+          next if i == 1 || (i == 2 && !Holdify.color)  # ---
+
+          render_line(line, lineno, width)
+        end.compact
+      end
+
+      def render_hunk(line)
+        width = 0
+        hunk  = line.gsub(/([-+]\d+),(\d+)\s+([-+]\d+),(\d+)/) do
+          v1, = $2.to_i - 1          # rubocop:disable Style/PerlBackrefs
+          v2  = $4.to_i - 1          # rubocop:disable Style/PerlBackrefs
+          width = (@yaml_lno + [v1, v2].max).to_s.length
+          "#{$1},#{v1} #{$3},#{v2}"  # rubocop:disable Style/PerlBackrefs
+        end
+        [width, hunk]
+      end
+
+      def render_line(line, lineno, width)
+        type   = line[0]
+        line   = line[1..]
+        gutter = if type == '+'
+                   ' ' * width
+                 else
+                   lineno[0] += 1
+                   lineno[0].to_s.rjust(width)
+                 end
+
+        "#{type}#{gutter} #{line}"
+      end
+    end
+
+    # Methods enabling ANSI feedback
+    module Color
+      SGR = { clear:   "\e[0m",
+              red:     "\e[31m",
+              green:   "\e[32m",
+              yellow:  "\e[33m",
+              magenta: "\e[35m" }.freeze
+
+      def wrap(color, string) = "#{SGR[color]}#{string}#{SGR[:clear]}"
+
+      def file_refs
+        refs = super
+        [wrap(:red, refs.shift), *refs.map { wrap(:green, _1) }]
+      end
+
+      def diff = [wrap(:red, "- #{@expected.inspect}"), wrap(:green, "+ #{@actual.inspect}")]
+
+      def xxhi_ref = wrap(:magenta, @xxhi_ref)
+
+      # Methods enabling the git-diff ANSI feedback
+      module GitDiff
+        def git_command = "git diff --no-index --color-words='[^ ]+|[ ]+' --unified=1000 #{@exp_path} #{@act_path}"
+
+        def render_line(line, lineno, width)
+          clean   = line.gsub(/\e\[(1|22|0)m/, '').lstrip
+          added   = clean.start_with?(SGR[:green]) && !line.include?(SGR[:red])
+          removed = clean.start_with?(SGR[:red]) && !line.include?(SGR[:green])
+          changed = line.include?(SGR[:red]) || line.include?(SGR[:green])
+
+          type, color = (added && ['+', :green]) || (removed && ['-', :red]) || (changed && ['~', :yellow])
+
+          sgr    = SGR[color].to_s if color
+          gutter = if added
+                     "#{sgr}#{type} #{' ' * width}#{SGR[:clear]}"
+                   else
+                     lineno[0] += 1
+                     "#{sgr}#{type || ' '}#{lineno[0].to_s.rjust(width)}#{SGR[:clear]}"
+                   end
+
+          "#{gutter} #{line}"
+        end
+      end
+    end
+  end
+end

data/lib/holdify/hold.rb

@@ -1,57 +1,56 @@
 # frozen_string_literal: true
 
 module Holdify
-  # The *_hold statement (Assertion/Expectation)
+  # The *_hold Assertion/Expectation
   class Hold
-    attr_reader :forced, :store
+    attr_reader :forced, :store, :test_loc, :session
 
     def initialize(test)
       @test    = test
       @path,   = test.method(test.name).source_location
       @store   = Holdify.stores(@path)
-      @session = Hash.new { |h, k| h[k] = [] } # { line => [values] }
+      @session = Hash.new { |h, k| h[k] = [] } # { lineno => [values] }
       @forced  = []                            # [ lines ]
       @added   = []                            # [ lines ]
     end
 
     def call(actual, force: false)
-      location = find_location
-      line     = location.lineno
-      raise "Could not find holdify statement at line #{line}" unless @store.xxh(line)
+      @test_loc = find_test_loc
+      lineno    = @test_loc.lineno
+      raise "Could not find holdify statement at lineno #{lineno}" unless @store.xxh(lineno)
 
-      @forced << line if force
+      @forced << lineno if force
 
-      values = @store.get(line)
-      index  = @session[line].size
+      values = @store.get_values(lineno)
+      index  = @session[lineno].size
       value  = if force || Holdify.reconcile
                  actual
                elsif values && index < values.size
                  values[index]
                else
-                 @added << line
+                 @added << lineno
                  actual
                end
 
-      @session[line] << value
+      @session[lineno] << value
       value
     end
 
     def save
-      @added.each   { |line| warn "[holdify] Held new value for #{@path}:#{line}" } unless Holdify.quiet
-      @session.each { |line, values| @store.set(line, values) }
+      @added.each   { |lineno| warn "[holdify] Held new value for #{Holdify.relative(@path)}:#{lineno}" } unless Holdify.quiet
+      @session.each { |lineno, values| @store.set_values(lineno, values) }
     end
 
-    # The index of the current test/value
-    def current_index(line) = @session[line].size - 1
-
-    # Find the location in the test that triggered the hold
-    def find_location
+    # Find the triggering LOC inside the test block/method
+    def find_test_loc
       caller_locations(2).find do |location|
         next unless location.path == @path
 
-        label = location.base_label
+        label  = location.base_label
         label == @test.name || label == '<top (required)>' || label == '<main>' || label.start_with?('<class:', '<module:')
       end
     end
+
+    def feedback(*) = Feedback.new(self, *).message
   end
 end

data/lib/holdify/source.rb

@@ -7,7 +7,7 @@ module Holdify
   class Source
     def initialize(path) = (@line_xxh, @xxh_lines = parse(path))
 
-    def xxh(line) = @line_xxh[line]
+    def xxh(lineno) = @line_xxh[lineno]
 
     def lines(xxh) = @xxh_lines[xxh]
 
@@ -17,13 +17,13 @@ module Holdify
       line_xxh  = {}
       xxh_lines = Hash.new { |h, k| h[k] = [] }
 
-      File.foreach(path).with_index(1) do |text, line|
+      File.foreach(path).with_index(1) do |text, lineno|
         content = text.strip
         next if content.empty?
 
-        xxh            = Digest::XXH3_64bits.hexdigest(content)
-        line_xxh[line] = xxh
-        xxh_lines[xxh] << line
+        xxh = Digest::XXH3_64bits.hexdigest(content)
+        line_xxh[lineno] = xxh
+        xxh_lines[xxh] << lineno
       end
 
       [line_xxh, xxh_lines]

data/lib/holdify/store.rb

@@ -1,20 +1,72 @@
 # frozen_string_literal: true
 
+require 'yaml'
+require 'fileutils'
 require 'forwardable'
-require_relative 'source'
-require_relative 'ledger'
 
 module Holdify
   # Interface to the Source (code) and the Ledger (data)
   class Store
+    class NoAliasVisitor < Psych::Visitors::YAMLTree # :nodoc:
+      def register(target, obj); end
+    end
+
+    def self.hold_dump(obj)
+      visitor = NoAliasVisitor.create
+      visitor << obj
+      visitor.tree.to_yaml
+    end
     extend Forwardable
 
+    def_delegator :@source, :xxh
+    attr_reader :path
+
     def initialize(path)
+      @path   = "#{path}#{Holdify.store_ext}"
       @source = Source.new(path)
-      @ledger = Ledger.new(path, @source)
+      FileUtils.rm_f(@path) if Holdify.reconcile
+      @data = File.exist?(@path) ? load_and_align : {}
     end
 
-    def_delegator  :@source, :xxh
-    def_delegators :@ledger, :get, :set, :persist, :lookup
+    def get_values(lineno) = @data[lineno]
+
+    def set_values(lineno, values) = (@data[lineno] = values)
+
+    def persist
+      return FileUtils.rm_f(@path) if @data.empty?
+
+      output = {}
+      @data.keys.sort.each do |lineno|
+        xxh = @source.xxh(lineno)
+        next unless xxh
+
+        output["L#{lineno} #{xxh}"] = @data[lineno]
+      end
+
+      File.write(@path, self.class.hold_dump(output))
+    end
+
+    private
+
+    def load_and_align
+      {}.tap do |aligned|
+        data = YAML.unsafe_load_file(@path) || {}
+        data.group_by { |k, _| k.split.last }.each do |xxh, entries|
+          lines = @source.lines(xxh)
+          next if lines.empty?
+
+          # Position of the held lines compared to the source lines
+          stayed, moved = entries.map { |key, values| { line: key[/\d+/].to_i, values: } }
+                                 .partition { lines.include?(_1[:line]) }
+          moved.sort_by! { _1[:line] }
+
+          # Align lines
+          lines.each do |lineno|
+            match           = stayed.find { _1[:line] == lineno } || moved.shift
+            aligned[lineno] = match[:values] if match
+          end
+        end
+      end
+    end
   end
 end

data/lib/holdify.rb

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
 
-require_relative 'holdify/store'
 require_relative 'holdify/hold'
+require_relative 'holdify/feedback'
+require_relative 'holdify/source'
+require_relative 'holdify/store'
 
 # The container module
 module Holdify
-  VERSION = '1.2.0'
-  CONFIG  = { ext: '.yaml' }.freeze
+  VERSION = '1.3.1'
 
   class << self
-    attr_accessor :reconcile, :quiet
+    attr_accessor :reconcile, :quiet, :git, :pwd, :color, :rel_paths, :store_ext
+
+    def persist_all! = @stores&.each_value(&:persist)
 
-    def config
-      @config ||= { git:   system('git --version', out: File::NULL, err: File::NULL),
-                    color: !ENV.key?('NO_COLOR') }
+    def relative(path)
+      return path unless rel_paths
+
+      path.sub(%r{^#{pwd}/}, '')
     end
 
     def stores(path = nil)
@@ -23,10 +27,6 @@ module Holdify
         @stores[path] ||= Store.new(path)
       end
     end
-
-    def persist_all!
-      @stores&.each_value(&:persist)
-    end
   end
   @mutex  = Mutex.new
   @stores = {}

data/lib/minitest/holdify_plugin.rb

@@ -1,27 +1,45 @@
 # frozen_string_literal: true
 
 require 'holdify'
-require 'holdify/failure'
 
 # Implement the minitest plugin
 module Minitest
-  # Register the after_run hook to persist all data
-  def self.plugin_holdify_init(_options)
-    Minitest.after_run { Holdify.persist_all! }
-  end
-
   # Set the Holdify options
-  def self.plugin_holdify_options(opts, _options)
-    opts.on '--holdify-reconcile', 'Reconcile the held values with the new ones' do
-      Holdify.reconcile = true
-      Holdify.quiet     = true
+  def self.plugin_holdify_options(opts, options)
+    opts.on '--holdify-reconcile', 'Reconcile the held values with the new ones (enables quiet)' do
+      options[:holdify_reconcile] = true
+      options[:holdify_quiet]     = true
     end
-
     opts.on '--holdify-quiet', 'Skip the warning on storing a new value' do
-      Holdify.quiet = true
+      options[:holdify_quiet] = true
+    end
+    opts.on '--holdify-no-git-diff', 'Disable git-diff' do
+      options[:holdify_no_git_diff] = true
+    end
+    opts.on '--holdify-no-color', 'Disable colored output' do
+      options[:holdify_no_color] = true
+    end
+    opts.on '--holdify-no-rel-paths', 'Disable relative paths in file references' do
+      options[:holdify_no_rel_paths] = true
+    end
+    opts.on '--holdify-store-ext EXT', 'The yaml store extension (default .yaml)' do |ext|
+      options[:holdify_store_ext] = ext
     end
   end
 
+  # Register the after_run hook to persist all data
+  def self.plugin_holdify_init(options)
+    Holdify.reconcile = options[:holdify_reconcile]
+    Holdify.quiet     = options[:holdify_quiet]
+    Holdify.git       = system('git --version', out: File::NULL, err: File::NULL) unless options[:holdify_no_git_diff]
+    Holdify.pwd       = Holdify.git ? `git rev-parse --show-toplevel`.strip : Dir.pwd
+    Holdify.color     = !ENV.key?('NO_COLOR') unless options[:holdify_no_color]
+    Holdify.rel_paths = true unless options[:holdify_no_rel_paths]
+    Holdify.store_ext = options[:holdify_store_ext] || '.yaml'
+
+    Minitest.after_run { Holdify.persist_all! }
+  end
+
   # Reopen the minitest class
   class Test
     # Ensure store is tidied and saved after the test runs
@@ -34,7 +52,7 @@ module Minitest
 
       path, = method(name).source_location
       msg   = +%([holdify] the value has been stored: remove the "!" suffix to pass the test\n)
-      msg  << @hold.forced.uniq.map { |line| "  #{path}:#{line}" }.join("\n")
+      msg  << @hold.forced.uniq.map { |lineno| "  #{path}:#{lineno}" }.join("\n")
 
       raise Minitest::Assertion, msg
     end
@@ -50,23 +68,17 @@ module Minitest
       expected = @hold.(actual, **)
 
       begin
-        if actual.nil?
+        if inspect
+          message = ['INSPECT[?]', message].compact.join(' ')
+          flunk(message)
+        elsif actual.nil?
           assert_nil expected, message
         else
           send(assertion || :assert_equal, expected, actual, message)
         end
       rescue Minitest::Assertion => e
-        location = @hold.find_location
-        metadata = @hold.store.lookup(location.lineno, @hold.current_index(location.lineno))
-        hold_msg = Holdify::Failure.new(expected, actual, e.message, metadata:, location:).message
-
-        msg = message ? "#{message}\n#{hold_msg}" : hold_msg
-        raise Minitest::Assertion, msg
-      end
-
-      if inspect
-        location = @hold.find_location
-        warn "[holdify] The value from #{location.path}:#{location.lineno} is:\n[holdify] => #{actual.inspect}"
+        feedback = @hold.feedback(e.location, expected, actual, message)
+        raise(Minitest::Assertion, feedback)
       end
 
       expected

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-holdify
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Domizio Demichelis
@@ -47,9 +47,8 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - lib/holdify.rb
-- lib/holdify/failure.rb
+- lib/holdify/feedback.rb
 - lib/holdify/hold.rb
-- lib/holdify/ledger.rb
 - lib/holdify/source.rb
 - lib/holdify/store.rb
 - lib/minitest-holdify.rb

data/lib/holdify/failure.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'tempfile'
-require 'open3'
-
-module Holdify
-  # Diff print failure report
-  class Failure
-    GUTTER_WIDTH = 3
-
-    def initialize(expected, actual, message, location:, metadata:)
-      @expected = expected
-      @actual   = actual
-      @message  = message
-      @location = location
-      @metadata = metadata
-      @config   = Holdify.config
-    end
-
-    def message
-      output = add_headers
-      @config[:git] ? output.push(*add_diff) : output.push(@message)
-      output.join("\n")
-    end
-
-    def add_headers
-      ["#{ansi[:red]}--- @yaml#{ansi[:reset]} >>> #{@metadata[:path]}:#{@metadata[:line]}",
-       "#{ansi[:green]}+++ @test#{ansi[:reset]} >>> #{@location.path}:#{@location.lineno}",
-       "#{ansi[:inverse]}<-- #{@metadata[:key]} #{ansi[:reset]}"]
-    end
-
-    def ansi
-      @config[:color] ? { inverse: "\e[7m", reset: "\e[0m", red: "\e[31m", green: "\e[32m" } : {}
-    end
-
-    def git_command
-      if @config[:color]
-        regex = '[^[:space:]]+|[[:space:]]+'
-        %W[git diff --no-index --color-words=#{regex} --unified=1000 #{@exp_file.path} #{@act_file.path}]
-      else
-        %W[git diff --no-index --no-color --unified=1000 #{@exp_file.path} #{@act_file.path}]
-      end
-    end
-
-    def add_diff
-      @exp_file = create_tempfile(@expected)
-      @act_file = create_tempfile(@actual)
-      @config[:color] ? color_process_lines : process_lines
-    rescue Errno::ENOENT
-      []
-    ensure
-      @exp_file&.close!
-      @act_file&.close!
-    end
-
-    def diff_lines
-      stdout, = Open3.capture3(*git_command)
-      return [] if stdout.to_s.empty?
-
-      # Match everything from the start up to the LAST @@...--- sequence
-      # .* is greedy, so it skips all earlier hunks
-      regex = /\A.*@@.*?\r?\n[[:blank:]]*---(\e\[[0-9;]*m)?\r?\n/m
-      body = stdout.sub(regex, '')
-
-      body.split(/\r?\n/)
-    end
-
-    def color_process_lines
-      line_num = @metadata[:line]
-      diff_lines.map do |line|
-        clean = line.gsub(/\e\[(1|22|0)m/, '').lstrip
-        added = clean.start_with?(ansi[:green]) && !line.include?(ansi[:red])
-
-        if added
-          gutter = ' ' * GUTTER_WIDTH
-        else
-          gutter = line_num.to_s.rjust(GUTTER_WIDTH)
-          line_num += 1
-        end
-
-        "#{ansi[:inverse]}#{gutter}#{ansi[:reset]} #{line}"
-      end
-    end
-
-    def process_lines
-      line_num = @metadata[:line]
-      diff_lines.map do |line|
-        type = line[0]
-        line = line[1..]
-
-        if type == '+'
-          gutter = ' ' * GUTTER_WIDTH
-        else
-          gutter = line_num.to_s.rjust(GUTTER_WIDTH)
-          line_num += 1
-        end
-
-        "#{gutter} #{type} #{line}"
-      end
-    end
-
-    def create_tempfile(obj)
-      Tempfile.new(%w[holdify .yaml]).tap do |file|
-        file.write(YAML.dump(obj))
-        file.flush
-      end
-    end
-  end
-end

data/lib/holdify/ledger.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'fileutils'
-
-module Holdify
-  # Manages the persistence and alignment of stored values
-  class Ledger
-    def initialize(path, source)
-      @path   = "#{path}#{CONFIG[:ext]}"
-      @source = source
-      FileUtils.rm_f(@path) if Holdify.reconcile
-      @data = File.exist?(@path) ? load_and_align : {}
-    end
-
-    def get(line) = @data[line]
-
-    def set(line, values) = (@data[line] = values)
-
-    def persist
-      return FileUtils.rm_f(@path) if @data.empty?
-
-      output = {}
-      @data.keys.sort.each do |line|
-        xxh = @source.xxh(line)
-        next unless xxh
-
-        output["L#{line} #{xxh}"] = @data[line]
-      end
-
-      content = YAML.dump(output)
-      File.write(@path, content)
-    end
-
-    # Used in Failure to get the actual storage metadata
-    def lookup(lineno, index = 0)
-      return unless File.exist?(@path)
-
-      xxh   = @source.xxh(lineno)
-      key   = "L#{lineno} #{xxh}"
-
-      found = false
-      count = -1
-
-      File.foreach(@path).with_index(1) do |content, ln|
-        if found
-          next unless content.start_with?('-')
-
-          count += 1
-          next unless count == index
-
-          return { path: @path, line: ln, key: key }
-        else
-          found = content.match(/\b#{xxh}\b/)
-        end
-      end
-    end
-
-    private
-
-    def load_and_align
-      {}.tap do |aligned|
-        data = YAML.unsafe_load_file(@path) || {}
-        data.group_by { |k, _| k.split.last }.each do |xxh, entries|
-          lines = @source.lines(xxh)
-          next if lines.empty?
-
-          # Position of the held lines compared to the source lines
-          stayed, moved = entries.map { |key, values| { line: key[/\d+/].to_i, values: } }
-                                 .partition { lines.include?(_1[:line]) }
-          moved.sort_by! { _1[:line] }
-
-          # Align lines
-          lines.each do |line|
-            match         = stayed.find { _1[:line] == line } || moved.shift
-            aligned[line] = match[:values] if match
-          end
-        end
-      end
-    end
-  end
-end