capybara-screenshot-diff 1.7.1 → 1.8.1

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

@@ -5,43 +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
-        include BrowserHelpers
-
         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.push(name).map(&:to_s)
+          File.join(*group_parts.push(name.to_s))
         end
 
         def screenshot_dir
-          File.join [Screenshot.screenshot_area] + group_parts
+          File.join(*([Screenshot.screenshot_area] + group_parts))
         end
 
         def screenshot_section(name)
@@ -50,104 +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, skip_stack_frames: 0, **options)
-          return false unless Screenshot.active?
-          return false if window_size_is_wrong?
-
-          driver_options = Diff.default_options.merge(options)
-
-          stability_time_limit = driver_options[:stability_time_limit]
-          wait = driver_options[:wait]
-          crop = calculate_crop_region(driver_options)
-
-          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"
-
-          create_output_directory_for(file_name)
-
-          comparison = ImageCompare.new(file_name, nil, driver_options)
-          checkout_vcs(name, comparison.old_file_name, comparison.new_file_name)
-          take_comparison_screenshot(comparison, crop, stability_time_limit, wait)
-
-          return false unless comparison.old_file_exists?
-
-          # Allow nil or single or multiple areas
-          if driver_options[:skip_area]
-            comparison.skip_area = calculate_skip_area(driver_options[:skip_area], crop)
-          end
-
-          (@test_screenshots ||= []) << [caller[skip_stack_frames], name, comparison]
-
+        def schedule_match_job(job)
+          (@test_screenshots ||= []) << job
           true
         end
 
-        def assert_image_not_changed(caller, name, comparison)
-          return unless comparison.different?
-
-          "Screenshot does not match for '#{name}' #{comparison.error_message}\nat #{caller}"
+        def group_parts
+          parts = []
+          parts << @screenshot_section if @screenshot_section.present?
+          parts << @screenshot_group if @screenshot_group.present?
+          parts
         end
 
-        private
+        def screenshot(name, skip_stack_frames: 0, **options)
+          return false unless Screenshot.active?
 
-        def calculate_crop_region(driver_options)
-          crop_coordinates = driver_options.delete(:crop)
-          return nil unless crop_coordinates
+          screenshot_full_name = build_full_name(name)
+          job = build_screenshot_matches_job(screenshot_full_name, options)
 
-          crop_coordinates = bounds_for_css(crop_coordinates).first if crop_coordinates.is_a?(String)
-          Region.from_edge_coordinates(*crop_coordinates)
-        end
+          return false unless job
 
-        def create_output_directory_for(file_name)
-          FileUtils.mkdir_p File.dirname(file_name)
-        end
+          test_caller = caller(skip_stack_frames)
 
-        def take_comparison_screenshot(comparison, crop, stability_time_limit, wait)
-          blurred_input = prepare_page_for_screenshot(timeout: wait)
-          if stability_time_limit
-            take_stable_screenshot(
-              comparison,
-              crop: crop,
-              stability_time_limit: stability_time_limit,
-              wait: wait
-            )
+          if Screenshot::Diff.delayed
+            schedule_match_job([test_caller] + job)
           else
-            take_right_size_screenshot(comparison, crop: crop)
+            error_msg = assert_image_not_changed(job.first, job.last)
+            if error_msg
+              error = ASSERTION.new(error_msg)
+              error.set_backtrace(caller(2))
+              raise error
+            end
           end
-        ensure
-          blurred_input&.click
         end
 
-        def calculate_skip_area(skip_area, crop)
-          crop_region = crop && Region.new(*crop)
-          skip_area = Array(skip_area)
-
-          css_selectors, regions = skip_area.compact.partition { |region| region.is_a? String }
+        def assert_image_not_changed(name, comparison)
+          result = comparison.different?
 
-          result = []
-          result.concat(build_regions_for(bounds_for_css(*css_selectors))) unless css_selectors.empty?
-          result.concat(build_regions_for(regions.flatten&.each_slice(4))) unless regions.empty?
-          result.compact!
+          # 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
 
-          result.map! { |region| crop_region.find_relative_intersect(region) } if crop_region
+          return unless result
 
-          result
+          "Screenshot does not match for '#{name}' #{comparison.error_message}"
         end
 
-        def build_regions_for(coordinates)
-          coordinates.map do |region_coordinates|
-            Region.from_edge_coordinates(*region_coordinates)
-          end
+        private
+
+        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,42 +1,64 @@
 # 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} | git lfs smudge > #{redirect_target} ; exit ${PIPESTATUS[0]}`
           else
             `#{show_command} > #{redirect_target}`
           end
-          FileUtils.rm_f(target_file_name) unless $CHILD_STATUS == 0
-        end
 
-        def checkout_vcs(name, old_file_name, new_file_name)
-          svn_file_name = "#{Capybara::Screenshot.screenshot_area_abs}/.svn/text-base/#{name}.png.svn-base"
+          if $CHILD_STATUS != 0
+            FileUtils.rm_f(checkout_path)
+            false
+          else
+            true
+          end
+        end
 
-          if File.exist?(svn_file_name)
-            committed_file_name = svn_file_name
-            FileUtils.cp committed_file_name, 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 #{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, old_file_name
-              end
-            else
-              restore_git_revision(name, 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.7.1"
+      VERSION = "1.8.1"
     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,8 +44,8 @@ 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 }
@@ -54,6 +54,8 @@ module Capybara
       mattr_accessor(:driver) { :auto }
       mattr_accessor :tolerance
 
+      mattr_accessor(:screenshoter) { Screenshoter }
+
       AVAILABLE_DRIVERS = Utils.detect_available_drivers.freeze
       ASSERTION = Utils.detect_test_framework_assert
 
@@ -65,7 +67,7 @@ module Capybara
           shift_distance_limit: shift_distance_limit,
           skip_area: skip_area,
           stability_time_limit: Screenshot.stability_time_limit,
-          tolerance: tolerance || (driver == :vips ? 0.001 : nil),
+          tolerance: tolerance || ((driver == :vips) ? 0.001 : nil),
           wait: Capybara.default_max_wait_time
         }
       end
@@ -73,19 +75,13 @@ 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
+          if Screenshot.active? && @test_screenshots.present?
             track_failures(@test_screenshots, caller)
-            @test_screenshots = nil
+            @test_screenshots.clear
           end
         end
       end
@@ -96,7 +92,7 @@ module Capybara
 
       def track_failures(screenshots, original_caller)
         test_screenshot_errors = screenshots.map do |caller, name, compare|
-          assert_image_not_changed(caller, name, compare)
+          assert_image_not_changed(name, compare)
         end
 
         test_screenshot_errors.compact!

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, (Array[String] | String) original_caller) -> 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

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

@@ -0,0 +1,25 @@
+module ::Vips
+  class Image
+    def self.new_from_file: (String filename) -> Image
+  end
+end
+
+module Capybara
+  module Screenshot
+    module Diff
+      module Drivers
+        class VipsDriver < BaseDriver[Vips::Image]
+          class VipsUtil
+            def self.difference_area: (Vips::Image old_image, Vips::Image new_image, ?color_distance: ::Integer) -> Numeric
+
+            def self.difference_area_size_by: (Vips::Image difference_mask) -> Numeric
+
+            def self.difference_mask: (Vips::Image, Vips::Image, ?Numeric? color_distance) -> Vips::Image
+
+            def self.difference_region_by: (Vips::Image diff_mask) -> Region?
+          end
+        end
+      end
+    end
+  end
+end