capybara-screenshot-diff 1.8.0 → 1.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e982564438ee16c8ae6900407e80ab1921888bd83b14fc6efc1c9a20fb6b79d5
-  data.tar.gz: 4893ded8cd25dbf93d9147b21e3a1bf09d80c544a390648eae58ef46dca85c78
+  metadata.gz: ffbb0b50c61fc1dcab03db91256897bed64caa09d65d37ee39765aec52e3d6fb
+  data.tar.gz: 1c762e2084bf2629eae25fb5e38792ce2232bdd62edbdbf1bff5381c074b3edd
 SHA512:
-  metadata.gz: 146c1928e4fd32ac25d7ad6813f81adb6e6a82004ab2bd589281e8fbc130001f4cddea57e706d7023dcb760a0d907d9a766375ef25a851e44962db6bbdd3e80a
-  data.tar.gz: 474fca1d1a8e27508593efe4517f6fe2d58608693acba531943e3220d6ae169445963517da6b40b5f7c095f6ef27f038cf57c397f7e17e0f3cae728307f085cd
+  metadata.gz: 97356f772b607b1ff67b146d1726baabbef696b362187c5aa5833657a4a443e8a6e8a30dedec49a07bda4d115e2a7a5c8482e4ba64a958072d1aaf6cd9dab8a3
+  data.tar.gz: '05880832a40006772c5fd72b28a4ebe9c28ca36ef49e70f132cab55acf1b97135bcd86bdb4d1b19893961fb344b0268d1c5d708354412c9c99efad03d3da85ab'

data/Rakefile

@@ -17,23 +17,13 @@ Rake::TestTask.new("test:integration") do |t|
   t.test_files = FileList["test/integration/**/*_test.rb"]
 end
 
-Rake::TestTask.new("test:signatures") do |t|
-  ENV["RBS_TEST_DOUBLE_SUITE"] ||= "minitest"
-  ENV["RBS_TEST_TARGET"] ||= "Capybara::Screenshot::Diff::*"
-  ENV["RBS_TEST_OPT"] ||= "-rset -rpathname -Isig"
-
-  t.libs << "test"
-  t.ruby_opts << "-r rbs/test/setup"
-  t.test_files = FileList["test/**/*_test.rb"]
-end
-
 task "clobber" do
   puts "Cleanup tmp/*.png"
   FileUtils.rm_rf(Dir["./tmp/*"])
 end
 
 task "test:benchmark" do
-  require_relative "./scripts/benchmark/find_region_benchmark"
+  require_relative "scripts/benchmark/find_region_benchmark"
   benchmark = Capybara::Screenshot::Diff::Drivers::FindRegionBenchmark.new
 
   puts "For Medium Screen Size: 800x600"

data/capybara-screenshot-diff.gemspec

@@ -12,18 +12,17 @@ Gem::Specification.new do |spec|
   spec.summary = "Track your GUI changes with diff assertions"
   spec.description = "Save screen shots and track changes with graphical diff"
   spec.homepage = "https://github.com/donv/capybara-screenshot-diff"
-  spec.required_ruby_version = ">= 3.0.0"
+  spec.required_ruby_version = ">= 3.1"
   spec.license = "MIT"
   spec.metadata["allowed_push_host"] = "https://rubygems.org/"
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{(^(\.|tmp|bin|test|spec|features|gemfiles|scripts)/)|(^(\.|Dockerfile|CONTRIBUTING|README))})
+    f.match(%r{(^(\.|tmp|bin|test|spec|features|gemfiles|scripts|foo)/)|(^(\.|Dockerfile|CONTRIBUTING|README))})
   end
 
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "actionpack", ">= 6.1", "< 8"
+  spec.add_runtime_dependency "actionpack", ">= 7.0", "< 9"
   spec.add_runtime_dependency "capybara", ">= 2", "< 4"
-  spec.add_runtime_dependency "chunky_png", ">= 1.3", "< 2"
 end

data/gems.rb

@@ -8,13 +8,18 @@ gemspec path: __dir__
 gem "rake"
 
 # Image processing libraries
-gem "oily_png", platform: :ruby, git: "https://github.com/donv/oily_png", branch: "patch-2"
+gem "chunky_png", ">= 1.3", require: false
+gem "oily_png", platform: :ruby, git: "https://github.com/wvanbergen/oily_png", ref: "44042006e79efd42ce4b52c1d78a4c70f0b4b1b2"
 gem "ruby-vips", require: false
 
-# Test
-gem "minitest", require: false
-gem "minitest-stub-const", require: false
-gem "simplecov", require: false
+group :test do
+  gem "capybara", ">= 3.26"
+  gem "mutex_m" # Needed for RubyMine debugging.  Try removing it.
+  gem "minitest", require: false
+  gem "minitest-stub-const", require: false
+  gem "simplecov", require: false
+  gem "rspec", require: false
+end
 
 # Capybara Server
 gem "puma", require: false
@@ -22,8 +27,7 @@ gem "rackup", require: false
 
 # Capybara Drivers
 gem "cuprite", require: false
-gem "selenium-webdriver", require: false
-gem "webdrivers", "~> 5.0", require: false
+gem "selenium-webdriver", ">= 4.11", require: false
 
 # Test Frameworks
 # gem "cucumber", require: false
@@ -31,5 +35,4 @@ gem "webdrivers", "~> 5.0", require: false
 
 group :tools do
   gem "standard", require: false
-  gem "rbs", require: false, platform: :ruby
 end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Screenshot
+    module Diff
+      class AreaCalculator
+        def initialize(crop_coordinates, skip_area)
+          @crop_coordinates = crop_coordinates
+          @skip_area = skip_area
+        end
+
+        def calculate_crop
+          return @_calculated_crop if defined?(@_calculated_crop)
+          return @_calculated_crop = nil unless @crop_coordinates
+
+          # TODO: Move out from this class, this should be done on before screenshot and should not depend on Browser
+          @crop_coordinates = BrowserHelpers.bounds_for_css(@crop_coordinates).first if @crop_coordinates.is_a?(String)
+          @_calculated_crop = Region.from_edge_coordinates(*@crop_coordinates)
+        end
+
+        # Cast skip areas params into Region
+        # and if there is crop then makes absolute coordinates to eb relative to crop top left corner
+        def calculate_skip_area
+          return nil unless @skip_area
+
+          crop_region = calculate_crop
+          skip_area = Array(@skip_area)
+
+          css_selectors, coords_list = skip_area.compact.partition { |region| region.is_a? String }
+          regions, coords_list = coords_list.partition { |region| region.is_a? Region }
+
+          regions.concat(build_regions_for(BrowserHelpers.bounds_for_css(*css_selectors))) unless css_selectors.empty?
+          regions.concat(build_regions_for(coords_list.flatten.each_slice(4))) unless coords_list.empty?
+
+          regions.compact!
+
+          if crop_region
+            regions
+              .map! { |region| crop_region.find_relative_intersect(region) }
+              .filter! { |region| region&.present? }
+          end
+
+          regions
+        end
+
+        private
+
+        def build_regions_for(coordinates)
+          coordinates
+            .map { |entry| Region.from_edge_coordinates(*entry) }
+            .tap { |it| it.compact! }
+        end
+      end
+    end
+  end
+end

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

@@ -30,13 +30,13 @@ module Capybara
 
       IMAGE_WAIT_SCRIPT = <<~JS
         function pending_image() {
-          var images = document.images;
+          const images = document.images
           for (var i = 0; i < images.length; i++) {
-            if (!images[i].complete) {
-                return images[i].src;
+            if (!images[i].complete && images[i].loading !== "lazy") {
+                return images[i].src
             }
           }
-          return false;
+          return false
         }(window)
       JS
 
@@ -83,7 +83,7 @@ module Capybara
       end
 
       def self.region_for(element)
-        element.evaluate_script(GET_BOUNDING_CLIENT_RECT_SCRIPT).map { |point| point.negative? ? 0 : point.to_i }
+        element.evaluate_script(GET_BOUNDING_CLIENT_RECT_SCRIPT).map { |point| point.negative? ? 0 : point.ceil.to_i }
       end
 
       def self.session

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Capybara::Screenshot::Diff
+  class Comparison < Struct.new(:new_image, :base_image, :options, :driver, :new_image_path, :base_image_path)
+  end
+end

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

@@ -1,11 +1,3 @@
 # frozen_string_literal: true
 
-require "capybara/screenshot/diff"
-require "capybara/screenshot/diff/test_methods"
-
-World(Capybara::Screenshot::Diff::TestMethods)
-
-Before do
-  Capybara::Screenshot::Diff.delayed = false
-  Capybara::Screenshot::BrowserHelpers.resize_to(Capybara::Screenshot.window_size) if Capybara::Screenshot.window_size
-end
+require "capybara_screenshot_diff/cucumber"

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

@@ -5,13 +5,17 @@ require "json"
 module Capybara
   module Screenshot
     module Diff
-      class Difference < Struct.new(:region, :meta, :comparison)
+      class Difference < Struct.new(:region, :meta, :comparison, :failed_by)
         def different?
-          !(blank? || tolerable?)
+          failed? || !(blank? || tolerable?)
         end
 
-        def base_image
-          comparison.base_image
+        def equal?
+          !different?
+        end
+
+        def failed?
+          !!failed_by
         end
 
         def options

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "chunky_png"
 require "capybara/screenshot/diff/difference"
 
 module Capybara
@@ -31,10 +30,6 @@ module Capybara
           def dimension(image)
             [width_for(image), height_for(image)]
           end
-
-          def inscribed?(dimensions, i)
-            width_for(i) < dimensions[0] || height_for(i) < dimensions[1]
-          end
         end
       end
     end

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

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-require "chunky_png"
+begin
+  require "chunky_png"
+rescue LoadError => e
+  raise 'Required chunky_png gem is missing. Add `gem "chunky_png"` to Gemfile' if e.message.match?(/chunky_png/i)
+  raise
+end
 
 require "capybara/screenshot/diff/drivers/base_driver"
 
@@ -35,12 +40,12 @@ module Capybara
             i.crop(*region.to_top_left_corner_coordinates)
           end
 
-          def from_file(filename)
-            ChunkyPNG::Image.from_file(filename.to_s)
+          def from_file(filename_or_path)
+            ChunkyPNG::Image.from_file(filename_or_path.to_s)
           end
 
           def save_image_to(image, filename)
-            image.save(filename)
+            image.save(filename, :fast_rgba)
           end
 
           def resize_image_to(image, new_width, new_height)
@@ -48,7 +53,7 @@ module Capybara
           end
 
           def load_image_files(old_file_name, file_name)
-            [File.binread(old_file_name), File.binread(file_name)]
+            [old_file_name.binread, file_name.binread]
           end
 
           def draw_rectangles(images, region, (r, g, b), offset: 0)

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

@@ -3,7 +3,7 @@
 begin
   require "vips"
 rescue LoadError => e
-  warn 'Required ruby-vips gem is missing. Add `gem "ruby-vips"` to Gemfile' if e.message.include?("vips")
+  raise 'Required ruby-vips gem is missing. Add `gem "ruby-vips"` to Gemfile' if e.message.match?(/vips/i)
   raise
 end
 
@@ -15,6 +15,8 @@ module Capybara
       # Compare two images and determine if they are equal, different, or within some comparison
       # range considering color values and difference area size.
       module Drivers
+        DEFAULT_HIGHLIGHT_COLOR = [255, 0, 0, 255].freeze
+
         class VipsDriver < BaseDriver
           def find_difference_region(comparison)
             new_image, base_image, options = comparison.new_image, comparison.base_image, comparison.options
@@ -26,9 +28,8 @@ module Capybara
             result = Difference.new(region, {}, comparison)
 
             unless result.blank?
-              meta = {}
-              meta[:difference_level] = difference_level(diff_mask, base_image) if comparison.options[:tolerance]
-              result.meta = meta
+              result.meta[:difference_level] = difference_level(diff_mask, base_image) if comparison.options[:tolerance]
+              result.meta[:diff_mask] = diff_mask
             end
 
             result
@@ -49,6 +50,8 @@ module Capybara
           end
 
           def add_black_box(memo, region)
+            return memo unless region
+
             memo.draw_rect([0, 0, 0, 0], *region.to_top_left_corner_coordinates, fill: true)
           end
 
@@ -100,6 +103,14 @@ module Capybara
             (comparison.new_image == comparison.base_image).min == 255
           end
 
+          def merge(new_image, base_image)
+            base_image.composite2(new_image, :over)
+          end
+
+          def highlight_mask(diff_mask, merged_image, color: DEFAULT_HIGHLIGHT_COLOR)
+            diff_mask.ifthenelse(color, merged_image * 0.75)
+          end
+
           private
 
           def same_as?(region, base_image)

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

@@ -5,7 +5,7 @@ module Capybara
     module Diff
       module Drivers
         def self.for(driver_options = {})
-          driver_option = driver_options.fetch(:driver, :chunky_png)
+          driver_option = driver_options.is_a?(Hash) ? driver_options.fetch(:driver, :chunky_png) : driver_options
           return driver_option unless driver_option.is_a?(Symbol)
 
           Utils.find_driver_class_for(driver_option).new

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "capybara/screenshot/diff/comparison"
+
 module Capybara
   module Screenshot
     module Diff
@@ -11,22 +13,13 @@ module Capybara
         TOLERABLE_OPTIONS = [:tolerance, :color_distance_limit, :shift_distance_limit, :area_size_limit].freeze
 
         attr_reader :driver, :driver_options
-
-        attr_reader :annotated_image_path, :annotated_base_image_path,
-          :image_path, :base_image_path,
-          :new_file_name, :old_file_name
+        attr_reader :image_path, :base_image_path
+        attr_reader :difference, :error_message
 
         def initialize(image_path, base_image_path, options = {})
           @image_path = Pathname.new(image_path)
-
-          @new_file_name = @image_path.to_s
-          @annotated_image_path = @image_path.sub_ext(".diff.png")
-
           @base_image_path = Pathname.new(base_image_path)
 
-          @old_file_name = @base_image_path.to_s
-          @annotated_base_image_path = @base_image_path.sub_ext(".diff.png")
-
           @driver_options = options.dup
 
           @driver = Drivers.for(@driver_options)
@@ -35,121 +28,116 @@ module Capybara
         # Compare the two image files and return `true` or `false` as quickly as possible.
         # Return falsely if the old file does not exist or the image dimensions do not match.
         def quick_equal?
-          @error_message = nil
-          return false unless image_files_exist?
-          # TODO: Confirm this change. There are screenshots with the same size, but there is a big difference
+          require_images_exists!
+
+          # NOTE: This is very fuzzy logic, but so far it's helps to support current performance.
           return true if new_file_size == old_file_size
 
           comparison = load_and_process_images
 
           unless driver.same_dimension?(comparison)
-            @error_message = build_error_for_different_dimensions(comparison)
+            self.difference = build_failed_difference(comparison, {different_dimensions: true})
             return false
           end
 
-          return true if driver.same_pixels?(comparison)
+          if driver.same_pixels?(comparison)
+            self.difference = build_no_difference(comparison)
+            return true
+          end
 
-          # Could not make any difference to be tolerable, so skip and return as not equal
+          # NOTE: Could not make any difference to be tolerable, so skip and return as not equal.
           return false if without_tolerable_options?
 
-          @difference = driver.find_difference_region(comparison)
-          return true unless @difference.different?
+          self.difference = driver.find_difference_region(comparison)
 
-          @error_message = @difference.inspect
-          false
+          !difference.different?
         end
 
         # Compare the two image referenced by this object, and return `true` if they are different,
         # and `false` if they are the same.
         def different?
-          @error_message = nil
-
-          @error_message = _different?
-
-          clean_tmp_files unless @error_message
-
-          !@error_message.nil?
+          processed.difference.different?
         end
 
-        def build_error_for_different_dimensions(comparison)
-          change_msg = [comparison.base_image, comparison.new_image]
-            .map { |i| driver.dimension(i).join("x") }
-            .join(" => ")
-
-          "Screenshot dimension has been changed for #{@new_file_name}: #{change_msg}"
+        def dimensions_changed?
+          difference.failed_by&.[](:different_dimensions)
         end
 
-        def clean_tmp_files
-          @annotated_base_image_path.unlink if @annotated_base_image_path.exist?
-          @annotated_image_path.unlink if @annotated_image_path.exist?
+        def reporter
+          @reporter ||= begin
+            current_difference = difference || build_no_difference(nil)
+            Capybara::Screenshot::Diff::Reporters::Default.new(current_difference)
+          end
         end
 
-        def save(image, image_path)
-          driver.save_image_to(image, image_path.to_s)
+        def processed?
+          !!difference
         end
 
-        def image_files_exist?
-          @base_image_path.exist? && @image_path.exist?
+        def processed
+          self.difference = find_difference unless processed?
+          @error_message ||= reporter.generate
+          self
         end
 
-        NEW_LINE = "\n"
-
-        attr_reader :error_message
-
         private
 
-        def without_tolerable_options?
-          (@driver_options.keys & TOLERABLE_OPTIONS).empty?
-        end
-
-        def _different?
-          raise "There is no original (base) screenshot version to compare, located: #{@base_image_path}" unless @base_image_path.exist?
-          raise "There is no new screenshot version to compare, located: #{@image_path}" unless @image_path.exist?
+        def find_difference
+          require_images_exists!
 
           comparison = load_and_process_images
 
           unless driver.same_dimension?(comparison)
-            return build_error_for_different_dimensions(comparison)
+            return build_failed_difference(comparison, {different_dimensions: true})
           end
 
-          return not_different if driver.same_pixels?(comparison)
+          if driver.same_pixels?(comparison)
+            build_no_difference(comparison)
+          else
+            driver.find_difference_region(comparison)
+          end
+        end
 
-          @difference = driver.find_difference_region(comparison)
-          return not_different unless @difference.different?
+        def require_images_exists!
+          raise ArgumentError, "There is no original (base) screenshot version to compare, located: #{base_image_path}" unless base_image_path.exist?
+          raise ArgumentError, "There is no new screenshot version to compare, located: #{image_path}" unless image_path.exist?
+        end
 
-          different(@difference)
+        def difference=(new_difference)
+          @error_message = nil
+          @reporter = nil
+          @difference = new_difference
         end
 
-        def load_and_process_images
-          images = driver.load_images(old_file_name, new_file_name)
-          base_image, new_image = preprocess_images(images)
-          Comparison.new(new_image, base_image, @driver_options)
+        def image_files_exist?
+          @base_image_path.exist? && @image_path.exist?
         end
 
-        def build_error_message(difference)
-          [
-            "(#{difference.inspect})",
-            new_file_name,
-            annotated_base_image_path.to_path,
-            annotated_image_path.to_path
-          ].join(NEW_LINE)
+        def without_tolerable_options?
+          (@driver_options.keys & TOLERABLE_OPTIONS).empty?
         end
 
-        def skip_area
-          @driver_options[:skip_area]
+        def build_failed_difference(comparison, failed_by)
+          Difference.new(
+            nil,
+            {difference_level: nil, max_color_distance: 0},
+            comparison,
+            failed_by
+          )
         end
 
-        def median_filter_window_size
-          @driver_options[:median_filter_window_size]
+        def load_and_process_images
+          images = driver.load_images(base_image_path, image_path)
+          base_image, new_image = preprocess_images(images)
+          Comparison.new(new_image, base_image, @driver_options, driver, image_path, base_image_path)
         end
 
-        def dimensions
-          @driver_options[:dimensions]
+        def skip_area
+          @driver_options[:skip_area]
         end
 
-        def different(difference)
-          annotate_and_save_images(difference)
-          build_error_message(difference)
+        def median_filter_window_size
+          @driver_options[:median_filter_window_size]
         end
 
         def preprocess_images(images)
@@ -159,17 +147,19 @@ module Capybara
         def preprocess_image(image)
           result = image
 
-          # FIXME: How can we access to this method from public interface? Is this not documented feature?
-          if dimensions && driver.inscribed?(dimensions, result)
-            result = driver.crop(dimensions, result)
-          end
-
           if skip_area
             result = ignore_skipped_area(result)
           end
 
           if median_filter_window_size
-            result = blur_image_by(image, median_filter_window_size)
+            if driver.is_a?(Drivers::VipsDriver)
+              result = blur_image_by(image, median_filter_window_size)
+            else
+              warn(
+                "[capybara-screenshot-diff] Median filter has been skipped for #{image_path} " \
+                  "because it is not supported by #{driver.class.name}"
+              )
+            end
           end
 
           result
@@ -180,48 +170,28 @@ module Capybara
         end
 
         def ignore_skipped_area(image)
-          skip_area.reduce(image) { |memo, region| driver.add_black_box(memo, region) }
+          skip_area&.reduce(image) { |memo, region| driver.add_black_box(memo, region) }
         end
 
         def old_file_size
-          @old_file_size ||= image_files_exist? && File.size(@old_file_name)
+          base_image_path.size
         end
 
         def new_file_size
-          File.size(@new_file_name)
-        end
-
-        def not_different
-          nil
+          image_path.size
         end
 
-        def annotate_and_save_images(difference)
-          annotate_and_save_image(difference, difference.comparison.new_image, @annotated_image_path)
-          annotate_and_save_image(difference, difference.comparison.base_image, @annotated_base_image_path)
+        def build_no_difference(comparison = nil)
+          Difference.new(
+            nil,
+            {difference_level: nil, max_color_distance: 0},
+            comparison || build_comparison
+          ).freeze
         end
 
-        def annotate_and_save_image(difference, image, image_path)
-          image = annotate_difference(image, difference.region)
-          image = annotate_skip_areas(image, difference.skip_area) if difference.skip_area
-          save(image, image_path.to_path)
-        end
-
-        DIFF_COLOR = [255, 0, 0, 255].freeze
-
-        def annotate_difference(image, region)
-          driver.draw_rectangles(Array[image], region, DIFF_COLOR, offset: 1).first
+        def build_comparison
+          Capybara::Screenshot::Diff::Comparison.new(nil, nil, driver_options, driver, image_path, base_image_path).freeze
         end
-
-        SKIP_COLOR = [255, 192, 0, 255].freeze
-
-        def annotate_skip_areas(image, skip_areas)
-          skip_areas.reduce(image) do |memo, region|
-            driver.draw_rectangles(Array[memo], region, SKIP_COLOR).first
-          end
-        end
-      end
-
-      class Comparison < Struct.new(:new_image, :base_image, :options)
       end
     end
   end