saboteur 0.2.0

data/lib/saboteur/reporter/terminal.rb

@@ -0,0 +1,136 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # Plain-text summary: counts per status, score, timings, skip reasons,
+    # errors, then a unified diff for each survivor.
+    class Terminal
+      MAX_ERRORS = 10
+
+      def initialize(out)
+        @out = out
+      end
+
+      def call(report)
+        summary(report)
+        warnings(report)
+        errors(report)
+        survivors(report)
+      end
+
+      private
+
+      def summary(report)
+        seed = report.seed && ", seed #{report.seed} (repeat with --seed #{report.seed})"
+        @out.puts "saboteur #{VERSION}: #{report.subjects.size} subjects, #{report.results.size} mutants, " \
+                  "wall #{format('%.2f', report.wall_time)} s#{seed}"
+        @out.puts status_line(report)
+        details(report)
+      end
+
+      def status_line(report)
+        c = report.counts
+        survived = "survived #{c[:survived]}"
+        ignored = report.survivors.size - report.unignored_survivors.size
+        survived += " (#{ignored} ignored)" if ignored.positive?
+        "killed #{c[:killed]}  #{survived}  timeout #{c[:timeout]}  resource limit #{c[:resource_limit]}  " \
+          "error #{c[:error]}  skipped #{c[:skipped]}"
+      end
+
+      def details(report)
+        score = report.score
+        @out.puts "score #{score ? format('%.1f %%', score * 100) : 'n/a'} " \
+                  "(killed+timeout)/(killed+survived+timeout); errors, resource limits and skips excluded"
+        mean = report.mean_runtime
+        @out.puts "mean time per executed mutant #{format('%.3f', mean)} s" if mean
+        @out.puts "invalid mutations dropped (did not parse): #{report.invalid_mutations}" if
+          report.invalid_mutations.positive?
+        report.skip_reasons.each { |reason, count| @out.puts "skipped: #{reason}: #{count}" }
+        reused = report.results.count(&:reused?)
+        @out.puts "reused #{reused} of #{report.results.size} verdicts from earlier runs (--incremental)" if
+          reused.positive?
+        kill_causes(report)
+      end
+
+      # How many kills came from a failed check and how many from a crash, and
+      # which operators mostly kill by crashing (their score says less).
+      def kill_causes(report)
+        killed = report.results.select { |result| result.status == :killed && result.kill_cause }
+        return if killed.empty?
+
+        crashes = killed.select(&:crash_kill?)
+        @out.puts "kills: #{killed.size - crashes.size} by a failed assertion, #{crashes.size} by a crash" \
+                  "#{crash_classes(crashes)}"
+        @out.puts "crash kills by operator: #{crashes_by_operator(killed)}" if crashes.any?
+      end
+
+      def crash_classes(crashes)
+        return "" if crashes.empty?
+
+        counts = crashes.map(&:kill_cause).tally.sort_by { |_, count| -count }
+        " (#{counts.map { |name, count| "#{name} #{count}" }.join(', ')})"
+      end
+
+      def crashes_by_operator(killed)
+        parts = killed.group_by { |result| result.mutation.operator }.filter_map do |operator, results|
+          count = results.count(&:crash_kill?)
+          "#{operator} #{count} of #{results.size}" if count.positive?
+        end
+        parts.join(", ")
+      end
+
+      def warnings(report)
+        report.warnings.each { |warning| @out.puts "warning: #{warning}" }
+      end
+
+      def errors(report)
+        errored = report.results.select { |result| result.status == :error }
+        return if errored.empty?
+
+        @out.puts "\nErrors (not counted as killed):"
+        errored.first(MAX_ERRORS).each do |result|
+          @out.puts "  #{result.subject.id} #{result.mutation.operator} #{result.digest}: " \
+                    "#{result.reason.to_s.lines.first&.strip}"
+        end
+        @out.puts "  ... #{errored.size - MAX_ERRORS} more" if errored.size > MAX_ERRORS
+      end
+
+      def survivors(report)
+        return if report.survivors.empty?
+
+        @out.puts "\nSurvivors:"
+        shown(report).each do |result, hidden|
+          location = "#{relative(result.subject.file, report.root)}:#{result.subject.start_line}"
+          @out.puts "\n#{result.subject.id} #{result.mutation.operator} #{result.digest} #{location}"
+          @out.puts "ignored: #{result.ignored}" if result.ignored
+          @out.puts result.diff(root: report.root)
+          @out.puts "#{hidden} more survivor#{'s' if hidden > 1} on this line in the JSON report" if hidden.positive?
+        end
+      end
+
+      # [[result, how many more on the same line]]. In review mode survivors
+      # on one line usually share a fate, so one is shown: live before
+      # ignored, then coarse before fine, then the earliest edit.
+      def shown(report)
+        return report.survivors.map { |result| [result, 0] } unless report.review?
+
+        lines = report.survivors.group_by { |result| [result.subject.file, edit_line(result)] }
+        lines.values.map do |same_line|
+          best = same_line.min_by do |result|
+            [result.ignored ? 1 : 0, result.mutation.coarse ? 0 : 1, result.mutation.edits.first.start_byte]
+          end
+          [best, same_line.size - 1]
+        end
+      end
+
+      def edit_line(result)
+        result.subject.line_of(result.mutation.edits.first.start_byte)
+      end
+
+      def relative(file, root)
+        file.delete_prefix("#{root}/")
+      end
+    end
+  end
+end

data/lib/saboteur/result.rb

@@ -0,0 +1,134 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "reporter/diff"
+
+module Saboteur
+  # resource_limit: the mutant's process tree hit the memory or process cap.
+  # Like error it is outside the score: a mutant that eats all memory was
+  # stopped by saboteur, not detected by a test.
+  STATUSES = %i[killed survived timeout resource_limit error skipped].freeze
+
+  # Outcome of one mutation. reason carries the skip reason, the error
+  # message or the timeout limit. ignored is the ignore-list reason, if any.
+  class MutantResult
+    attr_reader :subject, :mutation, :status, :reason, :runtime, :killed_by, :covered_by, :mutated_source,
+                :kill_cause
+    attr_accessor :ignored
+
+    def initialize(subject:, mutation:, status:, mutated_source:, reason: nil, runtime: nil, killed_by: [],
+                   covered_by: [], kill_cause: nil, reused: false)
+      raise ArgumentError, "unknown status #{status.inspect}" unless STATUSES.include?(status)
+
+      @subject = subject
+      @mutation = mutation
+      @status = status
+      @reason = reason
+      @runtime = runtime
+      @killed_by = killed_by
+      @covered_by = covered_by
+      @mutated_source = mutated_source
+      @kill_cause = kill_cause
+      @reused = reused
+      @ignored = nil
+    end
+
+    # The same mutant, marked as an error: its verdict did not hold up.
+    def as_error(reason)
+      MutantResult.new(subject: subject, mutation: mutation, status: :error, mutated_source: mutated_source,
+                       reason: reason, runtime: runtime, killed_by: killed_by, covered_by: covered_by)
+    end
+
+    def digest
+      @digest ||= mutation.digest(subject_start: subject.start_byte, original_source: subject.file_source)
+    end
+
+    def survived?
+      status == :survived
+    end
+
+    # Killed because a test's error, not its check, fired: NoMethodError and
+    # the like. Such kills say the code broke, not that a test verified it.
+    def crash_kill?
+      status == :killed && !kill_cause.nil? && kill_cause != "assertion"
+    end
+
+    # Taken from an earlier run (--incremental) instead of run again.
+    def reused?
+      @reused
+    end
+
+    def unignored_survivor?
+      survived? && ignored.nil?
+    end
+
+    def diff(root: nil)
+      path = root ? relative(subject.file, root) : subject.file
+      before, after = subject.surrounding_text
+      Reporter::Diff.unified(before + subject.source + after, before + mutated_source + after,
+                             path: path, first_line: subject.start_line)
+    end
+
+    private
+
+    def relative(file, root)
+      file.start_with?("#{root}/") ? file.delete_prefix("#{root}/") : file
+    end
+  end
+
+  # Everything one run produced.
+  class Report
+    attr_reader :results, :subjects, :wall_time, :invalid_mutations, :warnings, :root, :seed
+
+    # REVIEW: diff mode; the terminal then shows one survivor per line.
+    # seed: the random seed every test run started from (nil when unknown).
+    def initialize(results:, subjects:, wall_time:, root:, invalid_mutations: 0, warnings: [], review: false,
+                   seed: nil)
+      @results = results
+      @subjects = subjects
+      @wall_time = wall_time
+      @root = root
+      @invalid_mutations = invalid_mutations
+      @warnings = warnings
+      @review = review
+      @seed = seed
+    end
+
+    def review?
+      @review
+    end
+
+    def counts
+      STATUSES.to_h { |status| [status, results.count { |result| result.status == status }] }
+    end
+
+    # (killed + timeout) / (killed + survived + timeout); nil with nothing tested.
+    def score
+      c = counts
+      detected = c[:killed] + c[:timeout]
+      tested = detected + c[:survived]
+      tested.zero? ? nil : detected.fdiv(tested)
+    end
+
+    def survivors
+      results.select(&:survived?)
+    end
+
+    def unignored_survivors
+      results.select(&:unignored_survivor?)
+    end
+
+    def skip_reasons
+      results.select { |result| result.status == :skipped }.group_by(&:reason).transform_values(&:size)
+    end
+
+    def executed
+      results.reject { |result| result.status == :skipped }
+    end
+
+    def mean_runtime
+      timed = executed.reject(&:reused?).filter_map(&:runtime)
+      timed.empty? ? nil : timed.sum / timed.size
+    end
+  end
+end

data/lib/saboteur/selection/coverage_map.rb

@@ -0,0 +1,113 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "coverage"
+require "digest"
+require "fileutils"
+require "json"
+
+module Saboteur
+  module Selection
+    # file:line -> ids of the tests that executed that line.
+    #
+    # Built once per cache key in a forked child that runs the whole suite and
+    # takes a per-test delta with Coverage.result(stop: false, clear: true).
+    # Lines executed outside any test (before(:all), before(:suite)) are mapped
+    # to every test in the file of the next test that starts. Each test's
+    # duration is recorded so selected tests can run fastest first.
+    class CoverageMap
+      FORMAT = 3
+
+      attr_reader :lines, :tests, :build_seconds, :durations
+
+      # lines: { "/abs/file.rb" => { 12 => ["id1", "id2"] } }
+      # durations: { "id1" => seconds }
+      def initialize(lines:, tests:, build_seconds: nil, durations: {})
+        @lines = lines
+        @tests = tests
+        @build_seconds = build_seconds
+        @durations = durations
+      end
+
+      def tests_for(subject)
+        tests_for_lines(subject.file, subject.coverage_lines)
+      end
+
+      # Tests that executed any of the lines, fastest first (suite order breaks
+      # ties), no duplicates. With fail-fast, a mutant is killed by its
+      # cheapest killing test.
+      # The time the tests took while the map was built, or nil when one of
+      # them has no recorded duration.
+      def recorded_runtime(test_ids)
+        test_ids.sum { |id| durations.fetch(id) { return nil } }
+      end
+
+      def tests_for_lines(file, line_numbers)
+        by_line = lines[CoverageMap.canonical(file)]
+        return [] unless by_line
+
+        ids = line_numbers.flat_map { |line| by_line.fetch(line, []) }.uniq
+        order = test_order
+        ids.sort_by { |id| [durations.fetch(id, Float::INFINITY), order.fetch(id, Float::INFINITY)] }
+      end
+
+      # Lines refer to tests by their index in tests, which keeps the cache
+      # small for suites with long test ids.
+      def to_json(*)
+        index = test_order
+        encoded = lines.transform_values do |by_line|
+          by_line.to_h { |line, ids| [line.to_s, ids.map { |id| index.fetch(id) }] }
+        end
+        JSON.generate(format: FORMAT, tests: tests, build_seconds: build_seconds, lines: encoded,
+                      durations: tests.map { |id| durations[id]&.round(6) })
+      end
+
+      def self.from_json(json)
+        data = JSON.parse(json)
+        raise Error, "coverage map format #{data['format']} is not #{FORMAT}" unless data["format"] == FORMAT
+
+        tests = data["tests"]
+        lines = data["lines"].transform_values do |by_line|
+          by_line.to_h { |line, indexes| [line.to_i, indexes.map { |i| tests.fetch(i) }] }
+        end
+        durations = tests.zip(data["durations"]).to_h.compact
+        new(lines: lines, tests: tests, build_seconds: data["build_seconds"], durations: durations)
+      end
+
+      # Cache key over every input that can change which test runs which line.
+      def self.cache_key(files:, extra:)
+        digest = Digest::SHA256.new
+        digest << VERSION << "\0" << extra.to_s << "\0"
+        files.sort.each do |file|
+          digest << file << "\0" << (File.file?(file) ? Digest::SHA256.file(file).hexdigest : "missing") << "\0"
+        end
+        digest.hexdigest
+      end
+
+      def self.canonical(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.expand_path(path)
+      end
+
+      def self.load(path)
+        from_json(File.read(path)) if File.file?(path)
+      rescue JSON::ParserError, Error
+        nil
+      end
+
+      def save(path)
+        FileUtils.mkdir_p(File.dirname(path))
+        tmp = "#{path}.#{Process.pid}.tmp"
+        File.write(tmp, to_json)
+        File.rename(tmp, path)
+      end
+
+      private
+
+      def test_order
+        @test_order ||= tests.each_with_index.to_h
+      end
+    end
+  end
+end

data/lib/saboteur/selection/git_diff.rb

@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "open3"
+
+module Saboteur
+  module Selection
+    # Lines changed between the merge base of REF and HEAD, plus uncommitted
+    # changes, as { "/abs/path.rb" => Set[line numbers in the current file] }.
+    module GitDiff
+      NO_FILE = "/dev/null" # rubocop:disable Style/FileNull -- literal in git diff output
+      HUNK = /\A@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/
+
+      module_function
+
+      def changed_lines(ref, root:)
+        base = git(root, "merge-base", ref, "HEAD").strip
+        top = git(root, "rev-parse", "--show-toplevel").strip
+        parse(git(root, "-c", "core.quotePath=false", "diff", "--unified=0", "--no-color", "--no-ext-diff", base,
+                  "--"), top)
+      end
+
+      def parse(diff, top)
+        changes = Hash.new { |hash, file| hash[file] = Set.new }
+        file = nil
+        diff.each_line do |line|
+          if line.start_with?("+++ ")
+            path = unquote(line.chomp.delete_prefix("+++ ").delete_suffix("\t"))
+            file = path == NO_FILE ? nil : File.join(top, path.delete_prefix("b/"))
+          elsif file && (match = HUNK.match(line))
+            start = match[1].to_i
+            count = (match[2] || "1").to_i
+            # A pure deletion touches the lines on either side of it.
+            lines = count.zero? ? [start, start + 1] : (start...(start + count)).to_a
+            changes[file].merge(lines)
+          end
+        end
+        changes.default_proc = nil
+        changes
+      end
+
+      ESCAPES = { "n" => "\n", "t" => "\t", '"' => '"', "\\" => "\\", "a" => "\a", "b" => "\b",
+                  "f" => "\f", "r" => "\r", "v" => "\v" }.freeze
+
+      # git C-quotes a path with special bytes: "b/h\303\251llo.rb". It also
+      # ends a path that holds a space with a tab, which the caller strips.
+      def unquote(path)
+        return path unless path.start_with?('"') && path.end_with?('"')
+
+        path[1...-1].gsub(/\\([0-7]{3}|.)/) do
+          code = Regexp.last_match(1)
+          code.length == 3 ? code.to_i(8).chr : ESCAPES.fetch(code, code)
+        end.b.force_encoding(Encoding::UTF_8)
+      end
+
+      def git(root, *args)
+        out, err, status = Open3.capture3("git", *args, chdir: root)
+        raise Error, "git #{args.first} failed: #{err.strip}" unless status.success?
+
+        out
+      end
+    end
+  end
+end

data/lib/saboteur/selection/recorder.rb

@@ -0,0 +1,72 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "coverage"
+require_relative "coverage_map"
+
+module Saboteur
+  module Selection
+    # Collects per-test line deltas while the suite runs. The integration
+    # calls test_started / test_finished around every test.
+    class Recorder
+      def initialize(files)
+        @files = Set.new(files.map { |file| CoverageMap.canonical(file) })
+        @canonical = Hash.new { |hash, path| hash[path] = CoverageMap.canonical(path) }
+        @lines = Hash.new { |hash, file| hash[file] = Hash.new { |by_line, line| by_line[line] = [] } }
+        @tests = []
+        @tests_by_file = Hash.new { |hash, file| hash[file] = [] }
+        @outside = Hash.new { |hash, file| hash[file] = Set.new }
+        @durations = {}
+      end
+
+      def start
+        Coverage.resume if Coverage.state == :suspended
+        Coverage.result(stop: false, clear: true)
+      end
+
+      def test_started(id, test_file)
+        @tests << id
+        @tests_by_file[test_file] << id
+        each_hit_line { |file, line| @outside[test_file] << [file, line] }
+        @started_at = monotonic
+      end
+
+      def test_finished(id)
+        @durations[id] = monotonic - @started_at if @started_at
+        each_hit_line { |file, line| @lines[file][line] << id }
+      end
+
+      def result(build_seconds: nil)
+        @outside.each do |test_file, hits|
+          ids = @tests_by_file[test_file]
+          hits.each { |file, line| @lines[file][line] |= ids }
+        end
+        lines = @lines.transform_values { |by_line| by_line.transform_values(&:uniq) }
+        CoverageMap.new(lines: lines, tests: @tests, build_seconds: build_seconds, durations: @durations)
+      end
+
+      private
+
+      def monotonic
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      # Coverage is suspended while the delta is processed, so the recorder's
+      # own work (and anything it calls) is never attributed to a test.
+      def each_hit_line
+        snapshot = Coverage.result(stop: false, clear: true)
+        suspended = Coverage.running?
+        Coverage.suspend if suspended
+        snapshot.each do |path, data|
+          file = @canonical[path]
+          next unless @files.include?(file)
+
+          # Lines mode (set up by the executable); nil marks a line with no code.
+          data[:lines].each_with_index { |count, index| yield file, index + 1 if count&.positive? }
+        end
+      ensure
+        Coverage.resume if suspended
+      end
+    end
+  end
+end

data/lib/saboteur/subject.rb

@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  # One lexical scope enclosing a def: `module X`, `class X` or `class << self`.
+  Scope = Data.define(:kind, :path) do
+    def header
+      case kind
+      when :module then "module #{path}"
+      when :class then "class #{path}"
+      when :sclass then "class << self"
+      end
+    end
+
+    def sclass?
+      kind == :sclass
+    end
+  end
+
+  # A method defined with `def`: the unit saboteur mutates.
+  #
+  # Byte offsets index the file as read from disk. singleton is true for
+  # `def self.x` and for defs inside `class << self`; sclass is true only for
+  # the latter, because the def text must then be evaluated on the singleton.
+  class Subject
+    attr_reader :name, :owner, :singleton, :sclass, :file, :start_byte, :end_byte,
+                :start_line, :end_line, :nesting, :node, :file_source, :frozen_literals
+    attr_accessor :skip_reason
+
+    def initialize(name:, owner:, singleton:, sclass:, file:, node:, file_source:, nesting:, frozen_literals:)
+      @name = name
+      @owner = owner
+      @singleton = singleton
+      @sclass = sclass
+      @file = file
+      @node = node
+      @file_source = file_source
+      @nesting = nesting
+      @frozen_literals = frozen_literals
+      @start_byte = node.location.start_offset
+      @end_byte = node.location.end_offset
+      @start_line = node.location.start_line
+      @end_line = node.location.end_line
+      @skip_reason = nil
+    end
+
+    def id
+      "#{owner}#{singleton ? '.' : '#'}#{name}"
+    end
+
+    def source
+      @source ||= file_source.byteslice(start_byte, end_byte - start_byte).force_encoding(Encoding::UTF_8)
+    end
+
+    # Text on the def's first line before it, and on its last line after it,
+    # so diffs show whole lines with their indentation.
+    def surrounding_text
+      line_start = (file_source.byteslice(0, start_byte).rindex("\n") || -1) + 1
+      line_end = file_source.index("\n", end_byte) || file_source.bytesize
+      [file_source.byteslice(line_start, start_byte - line_start),
+       file_source.byteslice(end_byte, line_end - end_byte)].map { |text| text.force_encoding(Encoding::UTF_8) }
+    end
+
+    # Lines whose execution means the method body ran. For a multi-line def
+    # the def line itself runs at load time, so it is left out.
+    def coverage_lines
+      return [start_line] if start_line == end_line
+
+      ((start_line + 1)..end_line).to_a
+    end
+
+    # Lines whose execution means the edited code ran: from the first line of
+    # the innermost statement containing the edit to the edit's last line.
+    # A statement's first line always records a coverage event when it runs,
+    # so a test that never ran the edited code cannot have hit these lines.
+    # An edit outside every statement (signature, around the def, whole
+    # body) maps to the whole method.
+    def coverage_lines_for(edit)
+      statement = innermost_statement(node.body, edit.start_byte, edit.end_byte)
+      return coverage_lines unless statement
+
+      first = statement.location.start_line
+      last = line_of([edit.end_byte - 1, edit.start_byte].max)
+      (first..[last, first].max).to_a
+    end
+
+    # True when anything in the body can turn an error into a value: a
+    # rescue or else clause, a modifier rescue, a nested begin/rescue.
+    def recovers?
+      rescuing?(node.body)
+    end
+
+    # The 1-based line of the file that holds this byte offset.
+    def line_of(byte_offset)
+      file_source.byteslice(0, byte_offset).count("\n") + 1
+    end
+
+    def contains_line?(line)
+      line.between?(start_line, end_line)
+    end
+
+    # Applies the mutation's edits to this method's text and returns the
+    # mutated method text. Raises ArgumentError for edits outside the method
+    # or overlapping each other.
+    def apply(edits)
+      text = file_source.byteslice(start_byte, end_byte - start_byte).b
+      previous_start = nil
+      edits.sort_by(&:start_byte).reverse_each do |edit|
+        validate_edit!(edit, previous_start)
+        previous_start = edit.start_byte
+        relative = edit.start_byte - start_byte
+        text = text.byteslice(0, relative) + edit.replacement.b + text.byteslice((edit.end_byte - start_byte)..)
+      end
+      text.force_encoding(Encoding::UTF_8)
+    end
+
+    def to_s
+      id
+    end
+
+    private
+
+    def rescuing?(child)
+      case child
+      when nil, Prism::DefNode, Prism::ClassNode, Prism::ModuleNode then false
+      when Prism::RescueModifierNode then true
+      when Prism::BeginNode then !(child.rescue_clause.nil? && child.else_clause.nil?) || descend?(child)
+      else descend?(child)
+      end
+    end
+
+    def descend?(child)
+      child.compact_child_nodes.any? { |grandchild| rescuing?(grandchild) }
+    end
+
+    def innermost_statement(node, start_byte, end_byte, found = nil)
+      return found if node.nil?
+
+      if node.is_a?(Prism::StatementsNode)
+        statement = node.body.find do |child|
+          child.location.start_offset <= start_byte && end_byte <= child.location.end_offset
+        end
+        return found unless statement
+
+        found = statement
+        node = statement
+      end
+      node.compact_child_nodes.each do |child|
+        next unless child.location.start_offset <= start_byte && end_byte <= child.location.end_offset
+
+        return innermost_statement(child, start_byte, end_byte, found)
+      end
+      found
+    end
+
+    def validate_edit!(edit, previous_start)
+      unless File.expand_path(edit.file) == File.expand_path(file)
+        raise ArgumentError, "edit for #{edit.file} applied to subject in #{file}"
+      end
+      unless edit.start_byte >= start_byte && edit.end_byte <= end_byte
+        raise ArgumentError, "edit #{edit.start_byte}...#{edit.end_byte} is outside #{id} (#{start_byte}...#{end_byte})"
+      end
+      raise ArgumentError, "overlapping edits in mutation of #{id}" if previous_start && edit.end_byte > previous_start
+    end
+  end
+end