capybara-screenshot-diff 1.6.2 → 1.8.3

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

@@ -5,48 +5,41 @@ require "capybara"
 require "action_controller"
 require "action_dispatch"
 require "active_support/core_ext/string/strip"
+require "pathname"
+
+require_relative "drivers"
 require_relative "image_compare"
-require_relative "stabilization"
 require_relative "vcs"
+require_relative "browser_helpers"
+require_relative "region"
+
+require_relative "screenshot_matcher"
 
 # Add the `screenshot` method to ActionDispatch::IntegrationTest
 module Capybara
   module Screenshot
     module Diff
       module TestMethods
-        include Stabilization
-        include Vcs
-
         def initialize(*)
           super
           @screenshot_counter = nil
           @screenshot_group = nil
           @screenshot_section = nil
           @test_screenshot_errors = nil
-          @test_screenshots = nil
+          @test_screenshots = []
         end
 
-        def group_parts
-          parts = []
-          parts << @screenshot_section if @screenshot_section.present?
-          parts << @screenshot_group if @screenshot_group.present?
-          parts
-        end
+        def build_full_name(name)
+          if @screenshot_counter
+            name = format("%02i_#{name}", @screenshot_counter)
+            @screenshot_counter += 1
+          end
 
-        def full_name(name)
-          File.join group_parts.<<(name).map(&:to_s)
+          File.join(*group_parts.push(name.to_s))
         end
 
         def screenshot_dir
-          File.join [Screenshot.screenshot_area] + group_parts
-        end
-
-        def current_capybara_driver_class
-          Capybara.current_session.driver.class
-        end
-
-        def selenium?
-          current_capybara_driver_class <= Capybara::Selenium::Driver
+          File.join(*([Screenshot.screenshot_area] + group_parts))
         end
 
         def screenshot_section(name)
@@ -55,66 +48,67 @@ module Capybara
 
         def screenshot_group(name)
           @screenshot_group = name.to_s
-          @screenshot_counter = 0
+          @screenshot_counter = @screenshot_group.present? ? 0 : nil
           return unless Screenshot.active? && name.present?
 
           FileUtils.rm_rf screenshot_dir
         end
 
-        # @return [Boolean] whether a screenshot was taken
-        def screenshot(name, options = {})
+        def schedule_match_job(job)
+          (@test_screenshots ||= []) << job
+          true
+        end
+
+        def group_parts
+          parts = []
+          parts << @screenshot_section if @screenshot_section.present?
+          parts << @screenshot_group if @screenshot_group.present?
+          parts
+        end
+
+        def screenshot(name, skip_stack_frames: 0, **options)
           return false unless Screenshot.active?
-          return false if window_size_is_wrong?
 
-          driver_options = Diff.default_options.merge(options)
+          screenshot_full_name = build_full_name(name)
+          job = build_screenshot_matches_job(screenshot_full_name, options)
 
-          stability_time_limit = driver_options[:stability_time_limit]
-          wait = driver_options[:wait]
-          crop = driver_options.delete(:crop)
+          return false unless job
 
-          # Allow nil or single or multiple areas
-          if driver_options[:skip_area]
-            driver_options[:skip_area] = driver_options[:skip_area].compact.flatten&.each_slice(4)&.to_a
-          end
+          job.prepend(caller[skip_stack_frames])
 
-          if @screenshot_counter
-            name = "#{format("%02i", @screenshot_counter)}_#{name}"
-            @screenshot_counter += 1
-          end
-          name = full_name(name)
-          file_name = "#{Screenshot.screenshot_area_abs}/#{name}.png"
-
-          FileUtils.mkdir_p File.dirname(file_name)
-          comparison = ImageCompare.new(file_name, nil, driver_options)
-          checkout_vcs(name, comparison)
-          begin
-            blurred_input = prepare_page_for_screenshot(timeout: wait)
-            if stability_time_limit
-              take_stable_screenshot(comparison, stability_time_limit: stability_time_limit, wait: wait, crop: crop)
-            else
-              take_right_size_screenshot(comparison, crop: crop)
+          if Screenshot::Diff.delayed
+            schedule_match_job(job)
+          else
+            error_msg = assert_image_not_changed(*job)
+            if error_msg
+              error = ASSERTION.new(error_msg)
+              error.set_backtrace(caller(2))
+              raise error
             end
-          ensure
-            blurred_input&.click
           end
+        end
 
-          return false unless comparison.old_file_exists?
+        def assert_image_not_changed(caller, name, comparison)
+          result = comparison.different?
 
-          (@test_screenshots ||= []) << [caller(1..1).first, name, comparison]
+          # Cleanup after comparisons
+          if !result && comparison.base_image_path.exist?
+            FileUtils.mv(comparison.base_image_path, comparison.image_path, force: true)
+          else
+            FileUtils.rm_rf(comparison.base_image_path)
+          end
 
-          true
-        end
+          return unless result
 
-        def window_size_is_wrong?
-          selenium? && Screenshot.window_size &&
-            page.driver.browser.manage.window.size !=
-              ::Selenium::WebDriver::Dimension.new(*Screenshot.window_size)
+          "Screenshot does not match for '#{name}' #{comparison.error_message}\n#{caller}"
         end
 
-        def assert_image_not_changed(caller, name, comparison)
-          return unless comparison.different?
+        private
 
-          "Screenshot does not match for '#{name}' #{comparison.error_message}\nat #{caller}"
+        def build_screenshot_matches_job(screenshot_full_name, options)
+          ScreenshotMatcher
+            .new(screenshot_full_name, options)
+            .build_screenshot_matches_job
         end
       end
     end

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

@@ -1,41 +1,68 @@
 # frozen_string_literal: true
 
 require_relative "os"
+
 module Capybara
   module Screenshot
     module Diff
       module Vcs
         SILENCE_ERRORS = Os::ON_WINDOWS ? "2>nul" : "2>/dev/null"
 
-        def restore_git_revision(name, target_file_name)
-          redirect_target = "#{target_file_name} #{SILENCE_ERRORS}"
-          show_command = "git show HEAD~0:./#{Capybara::Screenshot.screenshot_area}/#{name}.png"
-          if Capybara::Screenshot.use_lfs
-            `#{show_command} | git lfs smudge > #{redirect_target}`
+        def self.restore_git_revision(screenshot_path, checkout_path)
+          vcs_file_path = screenshot_path.relative_path_from(Screenshot.root)
+
+          redirect_target = "#{checkout_path} #{SILENCE_ERRORS}"
+          show_command = "git show HEAD~0:./#{vcs_file_path}"
+          if Screenshot.use_lfs
+            `#{show_command} > #{checkout_path}.tmp #{SILENCE_ERRORS}`
+            if $CHILD_STATUS == 0
+              `git lfs smudge < #{checkout_path}.tmp > #{redirect_target}`
+            end
+            File.delete "#{checkout_path}.tmp"
           else
             `#{show_command} > #{redirect_target}`
           end
-          FileUtils.rm_f(target_file_name) unless $CHILD_STATUS == 0
+
+          if $CHILD_STATUS != 0
+            FileUtils.rm_f(checkout_path)
+            false
+          else
+            true
+          end
         end
 
-        def checkout_vcs(name, comparison)
-          svn_file_name = "#{Capybara::Screenshot.screenshot_area_abs}/.svn/text-base/#{name}.png.svn-base"
-          if File.exist?(svn_file_name)
-            committed_file_name = svn_file_name
-            FileUtils.cp committed_file_name, comparison.old_file_name
+        def self.checkout_vcs(screenshot_path, checkout_path)
+          if svn?
+            restore_svn_revision(screenshot_path, checkout_path)
           else
-            svn_info = `svn info #{comparison.new_file_name} #{SILENCE_ERRORS}`
-            if svn_info.present?
-              wc_root = svn_info.slice(/(?<=Working Copy Root Path: ).*$/)
-              checksum = svn_info.slice(/(?<=Checksum: ).*$/)
-              if checksum
-                committed_file_name = "#{wc_root}/.svn/pristine/#{checksum[0..1]}/#{checksum}.svn-base"
-                FileUtils.cp committed_file_name, comparison.old_file_name
-              end
-            else
-              restore_git_revision(name, comparison.old_file_name)
+            restore_git_revision(screenshot_path, checkout_path)
+          end
+        end
+
+        def self.restore_svn_revision(screenshot_path, checkout_path)
+          committed_file_name = screenshot_path + "../.svn/text-base/" + "#{screenshot_path.basename}.svn-base"
+          if committed_file_name.exist?
+            FileUtils.cp(committed_file_name, checkout_path)
+            return true
+          end
+
+          svn_info = `svn info #{screenshot_path} #{SILENCE_ERRORS}`
+          if svn_info.present?
+            wc_root = svn_info.slice(/(?<=Working Copy Root Path: ).*$/)
+            checksum = svn_info.slice(/(?<=Checksum: ).*$/)
+
+            if checksum
+              committed_file_name = "#{wc_root}/.svn/pristine/#{checksum[0..1]}/#{checksum}.svn-base"
+              FileUtils.cp(committed_file_name, checkout_path)
+              return true
             end
           end
+
+          false
+        end
+
+        def self.svn?
+          (Screenshot.screenshot_area_abs / ".svn").exist?
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module Capybara
   module Screenshot
     module Diff
-      VERSION = "1.6.2"
+      VERSION = "1.8.3"
     end
   end
 end

data/lib/capybara/screenshot/diff.rb

@@ -5,10 +5,10 @@ require "capybara/screenshot/diff/version"
 require "capybara/screenshot/diff/drivers/utils"
 require "capybara/screenshot/diff/image_compare"
 require "capybara/screenshot/diff/test_methods"
+require "capybara/screenshot/diff/screenshoter"
 
 module Capybara
   module Screenshot
-    extend Os
     mattr_accessor :add_driver_path
     mattr_accessor :add_os_path
     mattr_accessor :blur_active_element
@@ -30,10 +30,10 @@ module Capybara
       end
 
       def screenshot_area
-        parts = [Capybara::Screenshot.save_path]
-        parts << Capybara.current_driver.to_s if Capybara::Screenshot.add_driver_path
-        parts << os_name if Capybara::Screenshot.add_os_path
-        File.join parts
+        parts = [Screenshot.save_path]
+        parts << Capybara.current_driver.to_s if Screenshot.add_driver_path
+        parts << Os.name if Screenshot.add_os_path
+        File.join(*parts)
       end
 
       def screenshot_area_abs
@@ -44,23 +44,20 @@ module Capybara
     # Module to track screen shot changes
     module Diff
       include Capybara::DSL
-      include Capybara::Screenshot::Os
 
+      mattr_accessor(:delayed) { true }
       mattr_accessor :area_size_limit
       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) { 0.001 }
+      mattr_accessor :tolerance
+
+      mattr_accessor(:screenshoter) { Screenshoter }
 
       AVAILABLE_DRIVERS = Utils.detect_available_drivers.freeze
-      begin
-        require "minitest"
-        ASSERTION = Minitest::Assertion
-      rescue
-        ASSERTION = RuntimeError
-      end
+      ASSERTION = Utils.detect_test_framework_assert
 
       def self.default_options
         {
@@ -70,7 +67,7 @@ module Capybara
           shift_distance_limit: shift_distance_limit,
           skip_area: skip_area,
           stability_time_limit: Screenshot.stability_time_limit,
-          tolerance: tolerance,
+          tolerance: tolerance || ((driver == :vips) ? 0.001 : nil),
           wait: Capybara.default_max_wait_time
         }
       end
@@ -78,30 +75,36 @@ module Capybara
       def self.included(klass)
         klass.include TestMethods
         klass.setup do
-          if Capybara::Screenshot.window_size
-            if page.driver.respond_to?(:resize)
-              page.driver.resize(*Capybara::Screenshot.window_size)
-            elsif selenium?
-              page.driver.browser.manage.window.resize_to(*Capybara::Screenshot.window_size)
-            end
-          end
+          BrowserHelpers.resize_to(Screenshot.window_size) if Screenshot.window_size
         end
 
         klass.teardown do
-          if Capybara::Screenshot.active? && @test_screenshots
-            test_screenshot_errors = @test_screenshots
-              .map { |caller, name, compare| assert_image_not_changed(caller, name, compare) }
-            @test_screenshots = nil # release the comparison objects from memory
-            test_screenshot_errors.compact!
-            if test_screenshot_errors.any?
-              e = ASSERTION.new(test_screenshot_errors.join("\n\n"))
-              e.set_backtrace(caller)
-              if defined?(failures)
-                failures << e
-              else
-                raise e
-              end
-            end
+          if Screenshot.active? && @test_screenshots.present?
+            track_failures(@test_screenshots)
+            @test_screenshots.clear
+          end
+        end
+      end
+
+      private
+
+      EMPTY_LINE = "\n\n"
+
+      def track_failures(screenshots)
+        test_screenshot_errors = screenshots.map do |caller, name, compare|
+          assert_image_not_changed(caller, name, compare)
+        end
+
+        test_screenshot_errors.compact!
+
+        unless test_screenshot_errors.empty?
+          error = ASSERTION.new(test_screenshot_errors.join(EMPTY_LINE))
+          error.set_backtrace([])
+
+          if is_a?(::Minitest::Runnable)
+            failures << error
+          else
+            raise error
           end
         end
       end

data/sig/capybara/screenshot/diff/diff.rbs

@@ -0,0 +1,28 @@
+module Capybara
+  module Screenshot
+    def self.root=: ((String | Pathname) path) -> Pathname
+
+    def self.root: -> Pathname
+
+    def self.active?: () -> boolish
+
+    def self.screenshot_area: () -> String
+
+    def self.screenshot_area_abs: () -> Pathname
+
+    # Module to track screen shot changes
+    module Diff
+      AVAILABLE_DRIVERS: Array[(:vips | :chunky_png)]
+
+      ASSERTION: (top | RuntimeError)
+
+      def self.default_options: () -> ScreenshotMatcher::input_options
+
+      def self.included: (top klass) -> void
+
+      private
+
+      def track_failures: (Array[untyped] screenshots) -> void
+    end
+  end
+end

data/sig/capybara/screenshot/diff/difference.rbs

@@ -0,0 +1,33 @@
+module Capybara
+  module Screenshot
+    module Diff
+      class Difference
+        attr_reader comparison: ImageCompare::Comparison
+
+        def different?: () -> bool
+
+        def base_image: () -> top
+
+        def options: () -> Drivers::BaseDriver::options_entity
+
+        def tolerance: () -> Numeric?
+
+        def area_size_limit: () -> Numeric?
+
+        def blank?: () -> bool
+
+        def region_area_size: () -> Numeric
+
+        def ratio: () -> Numeric?
+
+        def to_h: () -> Hash[Symbol, untyped]
+
+        def coordinates: () -> Region::raw_region_entity
+
+        def inspect: () -> String
+
+        def tolerable?: () -> bool
+      end
+    end
+  end
+end

data/sig/capybara/screenshot/diff/drivers/base_driver.rbs

@@ -0,0 +1,63 @@
+module Capybara
+  module Screenshot
+    module Diff
+      module Drivers
+        class BaseDriver[ImageEntity]
+
+          type images_entity[out T] = [T, T]
+          type dimension_entity = [Numeric, Numeric]
+
+          type options_entity = {
+              area_size_limit?: Numeric?,
+              color_distance_limit?: Numeric?,
+              driver: (:auto | :vips | :chunky_png | VipsDriver | ChunkyPNGDriver)?,
+              dimensions: dimension_entity?,
+              median_filter_window_size: Numeric?,
+              shift_distance_limit?: Numeric?,
+              skip_area?: Array[Region]?,
+              stability_time_limit?: Numeric?,
+              tolerance?: Numeric?,
+              wait?: Numeric?
+            }
+
+          type color = [Integer, Integer, Integer, Integer]
+
+          def find_difference_region: (ImageEntity new_image, ImageEntity old_image, Numeric color_distance_limit, Numeric _shift_distance_limit, Integer _area_size_limit, ?fast_fail: bool) -> Difference
+
+          def inscribed?: (dimension_entity dimensions, ImageEntity i) -> boolish
+
+          def crop: (Region region, ImageEntity i) -> ImageEntity
+
+          def filter_image_with_median: (ImageEntity image, Numeric median_filter_window_size) -> ImageEntity
+
+          def add_black_box: (ImageEntity memo, Region region) -> void
+
+          def difference_level: (ImageEntity diff_mask, ImageEntity old_img, Region _region) -> Float
+
+          def image_area_size: (ImageEntity old_img) -> Integer
+
+          def height_for: (ImageEntity image) -> Integer
+
+          def width_for: (ImageEntity image) -> Integer
+
+          # Vips could not work with the same file. Per each process we require to create new file
+          def save_image_to: (ImageEntity image, String filename) -> void
+
+          def resize_image_to: (ImageEntity image, Integer new_width, Integer new_height) -> ImageEntity
+
+          def load_images: (String old_file_name, String new_file_name) -> images_entity[ImageEntity]
+
+          def from_file: (TestMethods::path_entity filename) -> ImageEntity
+
+          def dimension: (ImageEntity image) -> dimension_entity
+
+          def draw_rectangles: (images_entity[ImageEntity] images, Region region, color rgba, Integer offset) -> void
+
+          def same_pixels?: () -> boolish
+        end
+
+        def self.for: (ScreenshotMatcher::input_options) -> (VipsDriver | ChunkyPNGDriver)
+      end
+    end
+  end
+end

data/sig/capybara/screenshot/diff/drivers/browser_helpers.rbs

@@ -0,0 +1,36 @@
+module Capybara
+  class Result
+    def map: () -> Result
+  end
+  module Screenshot
+    module BrowserHelpers
+      def self.current_capybara_driver_class: () -> top
+
+      def self.selenium?: () -> boolish?
+
+      def self.window_size_is_wrong?: () -> boolish
+
+      def self.bounds_for_css: (*String css_selectors) -> Array[Region::raw_region_entity]
+
+      IMAGE_WAIT_SCRIPT: String
+
+      def self.pending_image_to_load: () -> top?
+
+      HIDE_CARET_SCRIPT: String
+
+      def self.hide_caret: () -> void
+
+      FIND_ACTIVE_ELEMENT_SCRIPT: String
+
+      type capybara_element = top
+
+      def self.blur_from_focused_element: () -> capybara_element?
+
+      GET_BOUNDING_CLIENT_RECT_SCRIPT: String
+
+      def self.all_visible_regions_for: (String selector) -> Array[Region::raw_region_entity]
+
+      def self.region_for: (Result element) -> Region::raw_region_entity
+    end
+  end
+end

data/sig/capybara/screenshot/diff/drivers/chunky_png_driver.rbs

@@ -0,0 +1,89 @@
+module ChunkyPNG
+  class Canvas
+  end
+
+  class Image
+    def self.from_blob: (String str) -> Image
+
+    def self.from_file: (String filename) -> Image
+  end
+end
+
+module Capybara
+  module Screenshot
+    module Diff
+      module Drivers
+        class ChunkyPNGDriver < BaseDriver[ChunkyPNG::Canvas]
+
+          def _load_images: (String old_file, String new_file) -> [ChunkyPNG::Image, ChunkyPNG::Image]
+
+          class DifferenceRegionFinder
+            def find_diff_rectangle: (
+                ChunkyPNG::Image org_img,
+                ChunkyPNG::Image new_img,
+                (Region | Region::raw_region_entity) area_coordinates,
+                cache: ImageCompare::cache_entity
+              ) -> Region?
+
+            def find_top: (
+                ChunkyPNG::Image old_img,
+                ChunkyPNG::Image new_img,
+                cache: ImageCompare::cache_entity
+              ) -> Region::raw_region_entity?
+
+            def find_left_right_and_top: (
+                ChunkyPNG::Image old_img,
+                ChunkyPNG::Image new_img,
+                (Region | Region::raw_region_entity) region,
+                cache: ImageCompare::cache_entity
+              ) -> Region::raw_region_entity
+
+            def find_bottom: (
+                ChunkyPNG::Image old_img,
+                ChunkyPNG::Image new_img,
+                Integer left,
+                Integer right,
+                Integer bottom,
+                cache: ImageCompare::cache_entity
+              ) -> Integer
+
+            def same_color?: (
+                ChunkyPNG::Image old_img,
+                ChunkyPNG::Image new_img,
+                Integer x,
+                Integer y,
+                ?cache: ImageCompare::cache_entity
+              ) -> boolish
+
+            def skipped_region?: (Integer x, Integer y) -> boolish
+
+            def color_distance_at: (
+                ChunkyPNG::Image new_img,
+                ChunkyPNG::Image old_img,
+                Integer x,
+                Integer y,
+                shift_distance_limit: Numeric?
+              ) -> Float
+
+            def shift_distance_at: (
+                ChunkyPNG::Image new_img,
+                ChunkyPNG::Image old_img,
+                Integer x,
+                Integer y,
+                color_distance_limit: Numeric?
+              ) -> Numeric
+
+            def color_matches: (
+                ChunkyPNG::Image new_img,
+                Integer org_color,
+                Integer x,
+                Integer y,
+                Numeric? color_distance_limit
+              ) -> boolish
+          end
+
+        end
+      end
+    end
+  end
+end

data/sig/capybara/screenshot/diff/drivers/utils.rbs

@@ -0,0 +1,13 @@
+module Capybara
+  module Screenshot
+    module Diff
+      module Utils
+        def self.detect_available_drivers: () -> Array[(:vips | :chunky_png)]
+
+        def self.find_driver_class_for: [T] (Symbol driver) -> T
+
+        def self.detect_test_framework_assert: [T < Exception] () -> T
+      end
+    end
+  end
+end