capybara-screenshot-diff 1.6.2 → 1.7.0

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

@@ -29,6 +29,10 @@ module Capybara
             reset
           end
 
+          def skip_area=(new_skip_area)
+            # noop
+          end
+
           # Resets the calculated data about the comparison with regard to the "new_image".
           # Data about the original image is kept.
           def reset
@@ -53,12 +57,6 @@ module Capybara
             [region, diff_mask]
           end
 
-          def size(region)
-            return 0 unless region
-
-            (region[2] - region[0]) * (region[3] - region[1])
-          end
-
           def adds_error_details_to(_log)
           end
 
@@ -68,8 +66,16 @@ module Capybara
             dimension(i) == dimensions || i.width < dimensions[0] || i.height < dimensions[1]
           end
 
-          def crop(dimensions, i)
-            i.crop(0, 0, *dimensions)
+          def crop(region, i)
+            result = i.crop(*region.to_top_left_corner_coordinates)
+
+            # FIXME: Vips is caching operations, and if we ware going to read the same file, he will use cached version for this
+            #       so after we cropped files and stored in the same file, the next load will recover old version instead of cropped
+            #       Workaround to make vips works with cropped versions
+            Vips.cache_set_max(0)
+            Vips.vips_cache_set_max(1000)
+
+            result
           end
 
           def filter_image_with_median(image, median_filter_window_size)
@@ -77,7 +83,7 @@ module Capybara
           end
 
           def add_black_box(memo, region)
-            memo.draw_rect([0, 0, 0, 0], *region, fill: true)
+            memo.draw_rect([0, 0, 0, 0], *region.to_top_left_corner_coordinates, fill: true)
           end
 
           def chunky_png_comparator
@@ -104,8 +110,14 @@ module Capybara
             image.width
           end
 
+          PNG_EXTENSION = ".png"
+
+          # Vips could not work with the same file. Per each process we require to create new file
           def save_image_to(image, filename)
-            image.write_to_file(filename)
+            ::Dir::Tmpname.create([filename, PNG_EXTENSION]) do |tmp_image_filename|
+              image.write_to_file(tmp_image_filename)
+              FileUtils.mv(tmp_image_filename, filename)
+            end
           end
 
           def resize_image_to(image, new_width, new_height)
@@ -125,10 +137,10 @@ module Capybara
             result
           end
 
-          def dimension_changed?(org_image, new_image)
-            return false if dimension(org_image) == dimension(new_image)
+          def dimension_changed?(old_image, new_image)
+            return false if dimension(old_image) == dimension(new_image)
 
-            change_msg = [org_image, new_image].map { |i| "#{i.width}x#{i.height}" }.join(" => ")
+            change_msg = [old_image, new_image].map { |i| "#{i.width}x#{i.height}" }.join(" => ")
             warn "Image size has changed for #{@new_file_name}: #{change_msg}"
 
             true
@@ -138,16 +150,16 @@ module Capybara
             [image.width, image.height]
           end
 
-          def draw_rectangles(images, (left, top, right, bottom), rgba)
+          def draw_rectangles(images, region, rgba)
             images.map do |image|
-              image.draw_rect(rgba, left - 1, top - 1, right - left + 2, bottom - top + 2)
+              image.draw_rect(rgba, region.left - 1, region.top - 1, region.width + 2, region.height + 2)
             end
           end
 
           class VipsUtil
             def self.difference(old_image, new_image, color_distance: 0)
               diff_mask = difference_mask(color_distance, new_image, old_image)
-              difference_region_by(diff_mask)
+              difference_region_by(diff_mask).to_edge_coordinates
             end
 
             def self.difference_area(old_image, new_image, color_distance: 0)
@@ -165,14 +177,17 @@ module Capybara
             end
 
             def self.difference_region_by(diff_mask)
-              columns, rows = diff_mask.project
+              columns, rows = diff_mask.bandor.project
 
               left = columns.profile[1].min
               right = columns.width - columns.flip("horizontal").profile[1].min
+
               top = rows.profile[0].min
               bottom = rows.height - rows.flip("vertical").profile[0].min
 
-              [left, top, right, bottom]
+              return nil if right < left || bottom < top
+
+              Region.from_edge_coordinates(left, top, right, bottom)
             end
           end
         end

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

@@ -12,9 +12,8 @@ module Capybara
 
         attr_reader :driver, :driver_options
 
-        attr_reader :annotated_new_file_name, :annotated_old_file_name, :area_size_limit,
-          :color_distance_limit, :new_file_name, :old_file_name, :shift_distance_limit,
-          :skip_area
+        attr_reader :annotated_new_file_name, :annotated_old_file_name, :new_file_name, :old_file_name, :skip_area
+        attr_accessor :shift_distance_limit, :area_size_limit, :color_distance_limit
 
         def initialize(new_file_name, old_file_name = nil, options = {})
           options = old_file_name if old_file_name.is_a?(Hash)
@@ -40,21 +39,23 @@ module Capybara
           super(@driver)
         end
 
+        def skip_area=(new_skip_area)
+          @skip_area = new_skip_area
+          driver.skip_area = @skip_area
+        end
+
         # Compare the two image files and return `true` or `false` as quickly as possible.
-        # Return falsish if the old file does not exist or the image dimensions do not match.
+        # Return falsely if the old file does not exist or the image dimensions do not match.
         def quick_equal?
           return false unless old_file_exists?
           return true if new_file_size == old_file_size
 
-          # old_bytes, new_bytes = load_image_files(@old_file_name, @new_file_name)
-          # return true if old_bytes == new_bytes
-
           images = driver.load_images(@old_file_name, @new_file_name)
           old_image, new_image = preprocess_images(images, driver)
 
           return false if driver.dimension_changed?(old_image, new_image)
 
-          region, meta = driver.find_difference_region(
+          self.difference_region, meta = driver.find_difference_region(
             new_image,
             old_image,
             @color_distance_limit,
@@ -63,14 +64,9 @@ module Capybara
             fast_fail: true
           )
 
-          self.difference_region = region
-
-          return true if difference_region_empty?(new_image, region)
-
-          return true if @area_size_limit && driver.size(region) <= @area_size_limit
-
-          return true if @tolerance && @tolerance >= driver.difference_level(meta, old_image, region)
-
+          return true if difference_region_area_size.zero? || difference_region_empty?(new_image, difference_region)
+          return true if @area_size_limit && difference_region_area_size <= @area_size_limit
+          return true if @tolerance && @tolerance >= driver.difference_level(meta, old_image, difference_region)
           # TODO: Remove this or find similar solution for vips
           return true if @shift_distance_limit && driver.shift_distance_equal?
 
@@ -79,41 +75,38 @@ module Capybara
 
         # Compare the two images referenced by this object, and return `true` if they are different,
         # and `false` if they are the same.
-        # Return `nil` if the old file does not exist or if the image dimensions do not match.
         def different?
-          return nil unless old_file_exists?
+          return false unless old_file_exists?
 
           images = driver.load_images(@old_file_name, @new_file_name)
-
           old_image, new_image = preprocess_images(images, driver)
 
           if driver.dimension_changed?(old_image, new_image)
-            save(new_image, old_image, @annotated_new_file_name, @annotated_old_file_name)
-
-            self.difference_region = 0, 0, driver.width_for(old_image), driver.height_for(old_image)
+            self.difference_region = Region.from_edge_coordinates(
+              0,
+              0,
+              [driver.width_for(old_image), driver.width_for(new_image)].min,
+              [driver.height_for(old_image), driver.height_for(new_image)].min
+            )
 
-            return true
+            return different(*images)
           end
 
-          region, meta = driver.find_difference_region(
+          self.difference_region, meta = driver.find_difference_region(
             new_image,
             old_image,
             @color_distance_limit,
             @shift_distance_limit,
             @area_size_limit
           )
-          self.difference_region = region
-
-          return not_different if difference_region_empty?(old_image, region)
-          return not_different if @area_size_limit && driver.size(region) <= @area_size_limit
-          return not_different if @tolerance && @tolerance > driver.difference_level(meta, old_image, region)
 
+          return not_different if difference_region_area_size.zero? || difference_region_empty?(old_image, difference_region)
+          return not_different if @area_size_limit && difference_region_area_size <= @area_size_limit
+          return not_different if @tolerance && @tolerance > driver.difference_level(meta, old_image, difference_region)
           # TODO: Remove this or find similar solution for vips
           return not_different if @shift_distance_limit && !driver.shift_distance_different?
 
-          annotate_and_save(images, region)
-
-          true
+          different(*images)
         end
 
         def clean_tmp_files
@@ -123,17 +116,6 @@ module Capybara
           File.delete(@annotated_new_file_name) if File.exist?(@annotated_new_file_name)
         end
 
-        DIFF_COLOR = [255, 0, 0, 255].freeze
-        SKIP_COLOR = [255, 192, 0, 255].freeze
-
-        def annotate_and_save(images, region = difference_region)
-          annotated_images = driver.draw_rectangles(images, region, DIFF_COLOR)
-          @skip_area.to_a.flatten.each_slice(4) do |region|
-            annotated_images = driver.draw_rectangles(annotated_images, region, SKIP_COLOR)
-          end
-          save(*annotated_images, @annotated_old_file_name, @annotated_new_file_name)
-        end
-
         def save(old_img, new_img, annotated_old_file_name, annotated_new_file_name)
           driver.save_image_to(old_img, annotated_old_file_name)
           driver.save_image_to(new_img, annotated_new_file_name)
@@ -148,25 +130,43 @@ module Capybara
           driver.reset
         end
 
+        NEW_LINE = "\n"
+
         def error_message
           result = {
-            area_size: driver.size(difference_region),
-            region: difference_region
+            area_size: difference_region_area_size,
+            region: difference_coordinates
           }
 
           driver.adds_error_details_to(result)
 
-          ["(#{result.to_json})", new_file_name, annotated_old_file_name, annotated_new_file_name].join("\n")
+          [
+            "(#{result.to_json})",
+            new_file_name,
+            annotated_old_file_name,
+            annotated_new_file_name
+          ].join(NEW_LINE)
         end
 
-        def difference_region
-          return nil unless @left || @top || @right || @bottom
+        def difference_coordinates
+          difference_region&.to_edge_coordinates
+        end
+
+        def difference_region_area_size
+          return 0 unless difference_region
 
-          [@left, @top, @right, @bottom]
+          difference_region.size
         end
 
         private
 
+        attr_accessor :difference_region
+
+        def different(old_image, new_image)
+          annotate_and_save([old_image, new_image], difference_region)
+          true
+        end
+
         def find_driver_class_for(driver)
           driver = AVAILABLE_DRIVERS.first if driver == :auto
 
@@ -183,23 +183,6 @@ module Capybara
             end
         end
 
-        def old_file_size
-          @old_file_size ||= old_file_exists? && File.size(@old_file_name)
-        end
-
-        def new_file_size
-          File.size(@new_file_name)
-        end
-
-        def not_different
-          clean_tmp_files
-          false
-        end
-
-        def load_images(old_file_name, new_file_name, driver = self)
-          [driver.from_file(old_file_name), driver.from_file(new_file_name)]
-        end
-
         def preprocess_images(images, driver = self)
           old_img = preprocess_image(images.first, driver)
           new_img = preprocess_image(images.last, driver)
@@ -225,19 +208,49 @@ module Capybara
           result
         end
 
-        def difference_region=(region)
-          @left, @top, @right, @bottom = region
+        def old_file_size
+          @old_file_size ||= old_file_exists? && File.size(@old_file_name)
+        end
+
+        def new_file_size
+          File.size(@new_file_name)
+        end
+
+        def not_different
+          clean_tmp_files
+          false
         end
 
         def difference_region_empty?(new_image, region)
           region.nil? ||
             (
-              region[1] == height_for(new_image) &&
-                region[0] == width_for(new_image) &&
-                region[2].zero? &&
-                region[3].zero?
+              region.height == height_for(new_image) &&
+                region.width == width_for(new_image) &&
+                region.x.zero? &&
+                region.y.zero?
             )
         end
+
+        def annotate_and_save(images, region)
+          annotated_images = annotate_difference(images, region)
+          annotated_images = annotate_skip_areas(annotated_images, @skip_area) if @skip_area
+
+          save(*annotated_images, @annotated_old_file_name, @annotated_new_file_name)
+        end
+
+        DIFF_COLOR = [255, 0, 0, 255].freeze
+
+        def annotate_difference(images, region)
+          driver.draw_rectangles(images, region, DIFF_COLOR)
+        end
+
+        SKIP_COLOR = [255, 192, 0, 255].freeze
+
+        def annotate_skip_areas(annotated_images, skip_areas)
+          skip_areas.reduce(annotated_images) do |annotated_images, region|
+            driver.draw_rectangles(annotated_images, region, SKIP_COLOR)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,86 @@
+# 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_top_left_corner_coordinates(x, y, width, height)
+    return nil unless x && y && width && height
+    return nil if width < 0 || height < 0
+
+    Region.new(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)
+    left <= x && x <= right && top <= y && y <= bottom
+  end
+end

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

@@ -8,28 +8,6 @@ module Capybara
       module Stabilization
         include Os
 
-        IMAGE_WAIT_SCRIPT = <<-JS.strip_heredoc.freeze
-          function pending_image() {
-            var images = document.images;
-            for (var i = 0; i < images.length; i++) {
-              if (!images[i].complete) {
-                  return images[i].src;
-              }
-            }
-            return false;
-          }()
-        JS
-
-        HIDE_CARET_SCRIPT = <<~JS
-          if (!document.getElementById('csdHideCaretStyle')) {
-            let style = document.createElement('style');
-            style.setAttribute('id', 'csdHideCaretStyle');
-            document.head.appendChild(style);
-            let styleSheet = style.sheet;
-            styleSheet.insertRule("* { caret-color: transparent !important; }", 0);
-          }
-        JS
-
         def take_stable_screenshot(comparison, stability_time_limit:, wait:, crop:)
           previous_file_name = comparison.old_file_name
           screenshot_started_at = last_image_change_at = Time.now
@@ -41,6 +19,7 @@ module Capybara
               clean_stabilization_images(comparison.new_file_name)
               break
             end
+
             comparison.reset
 
             if previous_file_name
@@ -78,7 +57,7 @@ module Capybara
         end
 
         def notice_how_to_avoid_this
-          unless @_csd_retina_warned
+          unless defined?(@_csd_retina_warned)
             warn "Halving retina screenshot.  " \
                 'You should add "force-device-scale-factor=1" to your Chrome chromeOptions args.'
             @_csd_retina_warned = true
@@ -90,7 +69,7 @@ module Capybara
         def build_snapshot_version_file_name(comparison, iteration, screenshot_started_at, stabilization_comparison)
           "#{comparison.new_file_name.chomp(".png")}" \
                 "_x#{format("%02i", iteration)}_#{(Time.now - screenshot_started_at).round(1)}s" \
-                "_#{stabilization_comparison.difference_region&.to_s&.gsub(", ", "_") || :initial}.png" \
+                "_#{stabilization_comparison.difference_coordinates&.to_s&.gsub(", ", "_") || :initial}.png" \
                 "#{ImageCompare::TMP_FILE_SUFFIX}"
         end
 
@@ -110,11 +89,7 @@ module Capybara
           new_height = expected_image_width * driver.height_for(saved_image) / driver.width_for(saved_image)
           resized_image = driver.resize_image_to(saved_image, expected_image_width, new_height)
 
-          Dir.mktmpdir do |dir|
-            resized_image_file = "#{dir}/resized.png"
-            driver.save_image_to(resized_image, resized_image_file)
-            FileUtils.mv(resized_image_file, file_name)
-          end
+          driver.save_image_to(resized_image, file_name)
         end
 
         def stabilization_images(base_file)
@@ -127,32 +102,31 @@ module Capybara
 
         def prepare_page_for_screenshot(timeout:)
           assert_images_loaded(timeout: timeout)
+
           if Capybara::Screenshot.blur_active_element
-            active_element = execute_script(<<-JS)
-              ae = document.activeElement;
-              if (ae.nodeName === "INPUT" || ae.nodeName === "TEXTAREA") {
-                  ae.blur();
-                  return ae;
-              }
-              return null;
-            JS
-            blurred_input = page.driver.send :unwrap_script_result, active_element
+            blurred_input = blur_from_focused_element
           end
-          execute_script(HIDE_CARET_SCRIPT) if Capybara::Screenshot.hide_caret
+
+          if Capybara::Screenshot.hide_caret
+            hide_caret
+          end
+
           blurred_input
         end
 
         def take_right_size_screenshot(comparison, crop:)
+          driver = comparison.driver
+
           save_screenshot(comparison.new_file_name)
 
           # TODO(uwe): Remove when chromedriver takes right size screenshots
-          reduce_retina_image_size(comparison.new_file_name, comparison.driver)
+          reduce_retina_image_size(comparison.new_file_name, driver)
           # ODOT
 
           if crop
-            full_img = comparison.driver.from_file(comparison.new_file_name)
-            area_img = full_img.crop(crop[0], crop[1], crop[2] - crop[0], crop[3] - crop[1])
-            comparison.driver.save_image_to(area_img, comparison.new_file_name)
+            image = driver.from_file(comparison.new_file_name)
+            cropped_image = driver.crop(crop, image)
+            driver.save_image_to(cropped_image, comparison.new_file_name)
           end
         end
 
@@ -193,7 +167,7 @@ module Capybara
 
           start = Time.now
           loop do
-            pending_image = evaluate_script IMAGE_WAIT_SCRIPT
+            pending_image = pending_image_to_load
             break unless pending_image
 
             assert(