snap_diff-capybara 0.0.1 → 2.0.0.alpha1

data/lib/capybara/screenshot/diff/browser_helpers.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): Capybara::Screenshot::BrowserHelpers now
+# resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::BrowserHelpers.
+require "snap_diff/browser_helpers"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/config_legacy.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Legacy Capybara::Screenshot / Capybara::Screenshot::Diff mattr_accessor
+# config module, extracted out of capybara_screenshot_diff.rb so it is a
+# leaf: it can be required by both capybara_screenshot_diff.rb (the old
+# umbrella entry point) and snap_diff.rb (the canonical entry point)
+# without either of *those* requiring the other back.
+#
+# Why this file has to exist at all: several lib/snap_diff/* units
+# (Screenshoter, SnapManager, Utils) are referenced here at class-body
+# eval time (mattr_accessor default blocks, AVAILABLE_DRIVERS) rather
+# than at call time, so they must be real, already-loaded classes before
+# this module body runs. Since v2 step 6 they are pulled in and referenced
+# under their canonical SnapDiff names: the old-name aliases are lazy
+# const_missing shims that emit deprecation warnings, and the gem's own
+# code must stay warning-free. Everything else this module references
+# (Os, Comparison) is referenced only inside method bodies, resolved
+# lazily at call time by whichever entry point loaded them.
+require "snap_diff/screenshoter"
+require "snap_diff/snap_manager"
+require "snap_diff/utils"
+
+module Capybara
+  module Screenshot
+    mattr_accessor :add_driver_path
+    mattr_accessor :add_os_path
+    mattr_accessor(:blur_active_element) { true }
+    mattr_accessor :enabled
+    mattr_accessor(:hide_caret) { true }
+    mattr_accessor :disable_animations
+    mattr_reader(:root) { (defined?(Rails) && defined?(Rails.root) && Rails.root) || Pathname(".").expand_path }
+    mattr_accessor :stability_time_limit
+    mattr_accessor :window_size
+    mattr_accessor(:save_path) { "doc/screenshots" }
+    mattr_accessor(:use_lfs)
+    mattr_accessor(:screenshot_format) { "png" }
+    mattr_accessor(:capybara_screenshot_options) { {} }
+
+    class << self
+      def root=(path)
+        @@root = Pathname(path).expand_path
+      end
+
+      def active?
+        enabled || (enabled.nil? && Diff.enabled)
+      end
+
+      def screenshot_area
+        parts = [Screenshot.save_path]
+        parts << SnapDiff::Os.name if Screenshot.add_os_path
+        parts << Capybara.current_driver.to_s if Screenshot.add_driver_path
+        File.join(*parts)
+      end
+
+      def screenshot_area_abs
+        root / screenshot_area
+      end
+    end
+
+    # Module to track screenshot changes
+    module Diff
+      mattr_accessor(:delayed) { true }
+      mattr_accessor :area_size_limit
+      mattr_accessor(:fail_if_new) { !ENV["CI"].nil? && !ENV["CI"].empty? }
+      mattr_accessor(:pending_if_new) { false }
+      mattr_accessor(:fail_on_difference) { true }
+      mattr_accessor :color_distance_limit
+      mattr_accessor(:enabled) { true }
+      mattr_accessor :shift_distance_limit
+      mattr_accessor :skip_area
+      mattr_accessor(:driver) { :auto }
+      mattr_accessor :tolerance
+      mattr_accessor :perceptual_threshold
+
+      mattr_accessor(:screenshoter) { SnapDiff::Screenshoter }
+      mattr_accessor(:manager) { SnapDiff::SnapManager }
+
+      AVAILABLE_DRIVERS = SnapDiff::Utils.detect_available_drivers.freeze
+
+      # Configure screenshot and diff settings in one block.
+      #
+      #   Capybara::Screenshot::Diff.configure do |screenshot, diff|
+      #     screenshot.window_size = [1280, 1024]
+      #     screenshot.stability_time_limit = 1
+      #     diff.driver = :vips
+      #     diff.tolerance = 0.0005
+      #   end
+      def self.configure
+        yield Screenshot, self
+      end
+
+      def self.compare(baseline_path, current_path, **options)
+        SnapDiff::Comparison.new(current_path, baseline_path, default_options.merge(options))
+      end
+
+      def self.default_options
+        {
+          area_size_limit: area_size_limit,
+          color_distance_limit: color_distance_limit,
+          driver: driver,
+          screenshot_format: Screenshot.screenshot_format,
+          capybara_screenshot_options: Screenshot.capybara_screenshot_options,
+          perceptual_threshold: perceptual_threshold,
+          shift_distance_limit: shift_distance_limit,
+          skip_area: skip_area,
+          stability_time_limit: Screenshot.stability_time_limit,
+          tolerance: tolerance || ((driver == :vips) ? 0.001 : nil),
+          wait: Capybara.default_max_wait_time
+        }
+      end
+    end
+  end
+end

data/lib/capybara/screenshot/diff/cucumber.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "snap_diff/integrations/cucumber"

data/lib/capybara/screenshot/diff/difference.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): the comparison-result value object lives at
+# SnapDiff::ComparisonResult (ex-Difference); the old name now resolves
+# lazily via snap_diff/legacy_shims' const_missing, with a deprecation
+# warning.
+require "snap_diff/comparison_result"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/drivers/base_driver.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# BaseDriver was dissolved into the SnapDiff::Driver mixin (ADR-004 v2
+# step 4); since step 6 the old name resolves lazily via
+# snap_diff/legacy_shims' const_missing, with a deprecation warning.
+# Note it is now a module -- `class MyDriver < BaseDriver` becomes
+# `include SnapDiff::Driver`.
+require "snap_diff/driver"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/drivers/chunky_png_driver.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 4): ChunkyPNGDriver lives in SnapDiff::Drivers
+# now; the module alias in capybara/screenshot/diff/drivers.rb makes it
+# reachable as Capybara::Screenshot::Diff::Drivers::ChunkyPNGDriver.
+require "capybara/screenshot/diff/drivers"
+require "snap_diff/drivers/chunky_png_driver"

data/lib/capybara/screenshot/diff/drivers/vips_driver.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 4): VipsDriver lives in SnapDiff::Drivers now;
+# the module alias in capybara/screenshot/diff/drivers.rb makes it reachable
+# as Capybara::Screenshot::Diff::Drivers::VipsDriver.
+require "capybara/screenshot/diff/drivers"
+require "snap_diff/drivers/vips_driver"

data/lib/capybara/screenshot/diff/drivers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): Capybara::Screenshot::Diff::Drivers now
+# resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::Drivers. The forwarded module is
+# the same object, so Drivers.for and the Drivers::VipsDriver /
+# Drivers::ChunkyPNGDriver constants keep resolving through the old name.
+require "snap_diff/drivers"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/image_compare.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): the comparison class lives at
+# SnapDiff::Comparison (ex-ImageCompare); the old name now resolves lazily
+# via snap_diff/legacy_shims' const_missing, with a deprecation warning.
+# snap_diff/comparison itself pulls in the ComparisonResult and Drivers
+# units, and the shims keep the old ::Difference / ::Drivers names
+# resolvable, so this path still provides everything the pre-move
+# image_compare.rb did. The internal Comparison struct and LOADED_DRIVERS
+# keep their legacy names and are defined by snap_diff/comparison.rb itself.
+require "snap_diff/comparison"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/image_preprocessor.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): Capybara::Screenshot::Diff::ImagePreprocessor
+# now resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::ImagePreprocessor.
+require "snap_diff/image_preprocessor"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/os.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "snap_diff/os"
+
+# Deliberately EAGER and silent (v2 step 6 exception): Os is an advertised
+# entry-point constant probed with Object.const_defined? by
+# support_load_probe_test.rb, and const_defined? never triggers
+# const_missing -- a lazy shim would break that contract. See
+# snap_diff/legacy_shims.rb for the full exception list.
+module Capybara
+  module Screenshot
+    Os = SnapDiff::Os
+  end
+end

data/lib/capybara/screenshot/diff/region.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+class Region
+  attr_accessor :x, :y, :width, :height
+
+  def initialize(x, y, width, height)
+    @x, @y, @width, @height = x, y, width, height
+  end
+
+  def self.from_edge_coordinates(left, top, right, bottom)
+    return nil unless left && top && right && bottom
+    return nil if right < left || bottom < top
+
+    Region.new(left, top, right - left, bottom - top)
+  end
+
+  def to_edge_coordinates
+    [left, top, right, bottom]
+  end
+
+  def to_top_left_corner_coordinates
+    [x, y, width, height]
+  end
+
+  def top
+    y
+  end
+
+  def bottom
+    y + height
+  end
+
+  def left
+    x
+  end
+
+  def right
+    x + width
+  end
+
+  def size
+    return 0 if width < 0 || height < 0
+
+    result = width * height
+    result.zero? ? 1 : result
+  end
+
+  def to_a
+    [@x, @y, @width, @height]
+  end
+
+  def find_intersect_with(region)
+    return nil unless intersect?(region)
+
+    new_left = [x, region.x].max
+    new_top = [y, region.y].max
+
+    Region.new(new_left, new_top, [right, region.right].min - new_left, [bottom, region.bottom].min - new_top)
+  end
+
+  def intersect?(region)
+    left <= region.right && right >= region.left && top <= region.bottom && bottom >= region.top
+  end
+
+  def move_by(right_by, down_by)
+    Region.new(x + right_by, y + down_by, width, height)
+  end
+
+  def find_relative_intersect(region)
+    intersect = find_intersect_with(region)
+    return nil unless intersect
+
+    intersect.move_by(-x, -y)
+  end
+
+  def cover?(x, y)
+    x.between?(left, right) && y.between?(top, bottom)
+  end
+
+  def empty?
+    width.zero? || height.zero?
+  end
+
+  def blank?
+    empty?
+  end
+
+  def present?
+    !empty?
+  end
+
+  def inspect
+    "Region(x: #{x}, y: #{y}, width: #{width}, height: #{height})"
+  end
+
+  # need to add this method to make it work with assert_equal
+  def ==(other)
+    case other
+    when Region
+      x == other.x && y == other.y && width == other.width && height == other.height
+    when Array
+      to_a == other
+    else
+      false
+    end
+  end
+end

data/lib/capybara/screenshot/diff/reporters/default.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "snap_diff/annotation_service"
+# Defines the Capybara::Screenshot::Diff namespace this file reopens.
+require "snap_diff/legacy_shims"
+
+module Capybara::Screenshot::Diff
+  module Reporters
+    class Default
+      attr_reader :difference
+
+      def initialize(difference)
+        @difference = difference
+        @annotation_service = SnapDiff::AnnotationService.new(difference)
+      end
+
+      def annotated_image_path
+        annotation_service.annotated_image_path
+      end
+
+      def annotated_base_image_path
+        annotation_service.annotated_base_image_path
+      end
+
+      def heatmap_diff_path
+        annotation_service.heatmap_diff_path
+      end
+
+      def generate
+        if difference.equal?
+          # NOTE: Delete previous run runtime files
+          clean_tmp_files
+          return nil
+        end
+
+        if difference.failed? && difference.failed_by[:different_dimensions]
+          return build_error_for_different_dimensions
+        end
+
+        annotate_and_save_images
+        build_error_message
+      end
+
+      def clean_tmp_files
+        annotation_service.clean_tmp_files
+      end
+
+      def annotate_and_save_images
+        annotation_service.annotate_and_save_images
+      end
+
+      def save_annotation_for(image, image_path)
+        annotation_service.save_annotation_for(image, image_path)
+      end
+
+      def annotate_difference(image, region)
+        annotation_service.annotate_difference(image, region)
+      end
+
+      def annotate_skip_areas(image, skip_areas)
+        annotation_service.annotate_skip_areas(image, skip_areas)
+      end
+
+      def save(image, image_path)
+        annotation_service.save(image, image_path)
+      end
+
+      def build_error_for_different_dimensions
+        change_msg = [comparison.base_image, comparison.new_image]
+          .map { |image| driver.dimension(image).join("x") }
+          .join(" => ")
+
+        "Dimensions have changed: #{change_msg}\n#{base_image_path.to_path}\n#{image_path.to_path}"
+      end
+
+      NEW_LINE = "\n"
+
+      def build_error_message
+        [
+          "(#{difference.to_h.to_json})",
+          image_path.to_path,
+          annotated_base_image_path.to_path,
+          annotated_image_path.to_path,
+          heatmap_diff_path.to_path
+        ].join(NEW_LINE)
+      end
+
+      private
+
+      attr_reader :annotation_service
+
+      def base_image_path
+        comparison.base_image_path
+      end
+
+      def image_path
+        comparison.new_image_path
+      end
+
+      def driver
+        @_driver ||= comparison.driver
+      end
+
+      def comparison
+        @_comparison ||= difference.comparison
+      end
+    end
+  end
+end

data/lib/capybara/screenshot/diff/screenshot_matcher.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): Capybara::Screenshot::Diff::ScreenshotMatcher
+# now resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::ScreenshotMatcher.
+require "snap_diff/screenshot_matcher"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/screenshoter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): Capybara::Screenshot::Screenshoter now
+# resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::Screenshoter.
+require "snap_diff/screenshoter"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/stable_screenshoter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): Capybara::Screenshot::Diff::StableScreenshoter
+# now resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::StableScreenshoter.
+require "snap_diff/stable_screenshoter"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/utils.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): Capybara::Screenshot::Diff::Utils now
+# resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::Utils.
+require "snap_diff/utils"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/vcs.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): Capybara::Screenshot::Diff::Vcs now
+# resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::Vcs.
+require "snap_diff/vcs"
+require "snap_diff/legacy_shims"

data/lib/capybara/screenshot/diff/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "snap_diff/version"
+
+# Deliberately EAGER and silent (v2 step 6 exception): the gemspec resolves
+# Capybara::Screenshot::Diff::VERSION at build time, so a lazy warning shim
+# would make every `gem build` warn. See snap_diff/legacy_shims.rb for the
+# full exception list.
+module Capybara
+  module Screenshot
+    module Diff
+      VERSION = SnapDiff::VERSION
+    end
+  end
+end

data/lib/capybara/screenshot/diff.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "capybara-screenshot-diff"

data/lib/capybara-screenshot-diff.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "capybara_screenshot_diff/minitest"

data/lib/capybara_screenshot_diff/attempts_reporter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): CapybaraScreenshotDiff::AttemptsReporter now
+# resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::AttemptsReporter.
+require "snap_diff/attempts_reporter"
+require "snap_diff/legacy_shims"

data/lib/capybara_screenshot_diff/cucumber.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Legacy entry point: pre-move, this path transitively loaded the whole gem
+# (via dsl -> umbrella). Preserve that contract for consumers who require
+# only this file.
+require "capybara_screenshot_diff"
+
+require "snap_diff/integrations/cucumber"

data/lib/capybara_screenshot_diff/dsl.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "snap_diff/dsl"
+
+# Deliberately EAGER and silent (v2 step 6 exception): DSL is an advertised
+# entry-point constant probed with Object.const_defined? by
+# support_load_probe_test.rb, and const_defined? never triggers
+# const_missing -- a lazy shim would break that contract. See
+# snap_diff/legacy_shims.rb for the full exception list.
+module CapybaraScreenshotDiff
+  DSL = SnapDiff::DSL
+end

data/lib/capybara_screenshot_diff/error_with_filtered_backtrace.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): CapybaraScreenshotDiff::BacktraceFilter and
+# CapybaraScreenshotDiff::ErrorWithFilteredBacktrace now resolve lazily via
+# snap_diff/legacy_shims' const_missing, with deprecation warnings pointing
+# at their SnapDiff:: replacements.
+require "snap_diff/error_with_filtered_backtrace"
+require "snap_diff/legacy_shims"

data/lib/capybara_screenshot_diff/minitest.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Legacy entry point: pre-move, this path transitively loaded the whole gem
+# (via dsl -> umbrella). Preserve that contract for consumers who require
+# only this file.
+require "capybara_screenshot_diff"
+
+require "snap_diff/integrations/minitest"
+
+module CapybaraScreenshotDiff
+  module Minitest
+    Assertions = SnapDiff::Minitest::Assertions
+  end
+end

data/lib/capybara_screenshot_diff/reporters/html.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): CapybaraScreenshotDiff::Reporters::HTML now
+# resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::Reporters::HTML.
+require "snap_diff/reporters/html"
+require "snap_diff/legacy_shims"

data/lib/capybara_screenshot_diff/rspec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Legacy entry point: pre-move, this path transitively loaded the whole gem
+# (via dsl -> umbrella). Preserve that contract for consumers who require
+# only this file.
+require "capybara_screenshot_diff"
+
+require "snap_diff/integrations/rspec"

data/lib/capybara_screenshot_diff/screenshot_assertion.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "snap_diff/screenshot_assertion"
+require "snap_diff/reporting"
+# ScreenshotAssertion / AssertionRegistry forward lazily (with deprecation
+# warnings) via snap_diff/legacy_shims' const_missing since v2 step 6.
+require "snap_diff/legacy_shims"
+
+# CapybaraScreenshotDiff's module methods cover two lifecycles with
+# different scopes, kept separate below:
+#
+# - Session lifecycle: thread-local, per-test. The AssertionRegistry holds
+#   the assertions and screenshot names of the test running on this thread;
+#   `reset` clears it between tests.
+# - Reporter lifecycle: process-global, suite-long. Owned by
+#   SnapDiff::Reporting; the methods here are thin public shims over it.
+#
+# `reset` is the one deliberate bridge between the two: a finished test's
+# assertions are handed to the reporters before the registry is cleared.
+module CapybaraScreenshotDiff
+  class << self
+    require "forwardable"
+    extend Forwardable
+
+    # --- Session lifecycle (thread-local, per-test) ---
+
+    def registry
+      Thread.current[:capybara_screenshot_diff_registry] ||= SnapDiff::AssertionRegistry.new
+    end
+
+    def_delegators :registry, :add_assertion, :assertions, :assertions_present?,
+      :failed_assertions, :record_new_screenshot, :new_screenshots,
+      :new_screenshots_present?, :screenshot_namer, :verify
+
+    def reset
+      notify_reporters(registry.assertions)
+      registry.reset
+    end
+
+    # Message to skip the test with when a new screenshot has no baseline yet
+    # and `pending_if_new` is enabled. Adapters call this after verifying
+    # screenshots, and skip the test with the returned message when present.
+    #
+    # @return [String, nil] the pending message, or nil when there is nothing to report
+    def pending_screenshots_message
+      return unless ::Capybara::Screenshot::Diff.pending_if_new && new_screenshots_present?
+
+      "No baseline for: #{new_screenshots.join(", ")}. Commit the captured screenshots to record them."
+    end
+
+    # --- Reporter lifecycle (process-global, suite-long) ---
+
+    def reporters
+      SnapDiff::Reporting.reporters
+    end
+
+    def reporters_mutex
+      SnapDiff::Reporting.mutex
+    end
+
+    def finalize_reporters!
+      SnapDiff::Reporting.finalize!
+    end
+
+    private
+
+    def notify_reporters(assertions)
+      SnapDiff::Reporting.notify(assertions)
+    end
+  end
+end

data/lib/capybara_screenshot_diff/screenshot_namer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): CapybaraScreenshotDiff::ScreenshotNamer now
+# resolves lazily via snap_diff/legacy_shims' const_missing, with a
+# deprecation warning pointing at SnapDiff::ScreenshotNamer.
+require "snap_diff/screenshot_namer"
+require "snap_diff/legacy_shims"

data/lib/capybara_screenshot_diff/snap.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Forwarder (ADR-004 v2 step 6): CapybaraScreenshotDiff::Snap now resolves
+# lazily via snap_diff/legacy_shims' const_missing, with a deprecation
+# warning pointing at SnapDiff::Snap.
+require "snap_diff/snap"
+require "snap_diff/legacy_shims"