capybara-screenshot-diff 1.3.1 → 1.4.0

data/gemfiles/rails42.gemfile

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
-eval File.read("#{__dir__}/common.gemfile")
+gems = "#{File.dirname __dir__}/gems.rb"
+eval File.read(gems), binding, gems
 
-gem 'actionpack', '~>4.2.7'
+gem "actionpack", "~>4.2.7"
+gem "bigdecimal", "<2", platform: :mri

data/gemfiles/rails50.gemfile

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
-eval File.read("#{__dir__}/common.gemfile")
+gems = "#{File.dirname __dir__}/gems.rb"
+eval File.read(gems), binding, gems
 
-gem 'actionpack', '~>5.0.1'
+gem "actionpack", "~>5.0.1"

data/gemfiles/rails51.gemfile

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
-eval File.read("#{__dir__}/common.gemfile")
+gems = "#{File.dirname __dir__}/gems.rb"
+eval File.read(gems), binding, gems
 
-gem 'actionpack', '~>5.1.2'
+gem "actionpack", "~>5.1.2"

data/gemfiles/rails52.gemfile

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
-eval File.read("#{__dir__}/common.gemfile")
+gems = "#{File.dirname __dir__}/gems.rb"
+eval File.read(gems), binding, gems
 
-gem 'actionpack', '~>5.2.1'
+gem "actionpack", "~>5.2.1"

data/gemfiles/rails60_gems.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+gems = "#{File.dirname __dir__}/gems.rb"
+eval File.read(gems), binding, gems
+
+gem "actionpack", "~> 6.0.1", "< 6.1"
+gem "capybara", ">= 2.15"
+gem "selenium-webdriver"

data/gemfiles/rails61_gems.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+gems = "#{File.dirname __dir__}/gems.rb"
+eval File.read(gems), binding, gems
+
+gem "actionpack", "~> 6.1.0", "< 6.2"
+gem "capybara", ">= 3.26"

data/gems.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in capybara-screenshot-diff.gemspec
+gemspec path: __dir__
+
+gem "rake"
+
+# Image processing libraries
+gem "oily_png", platform: :ruby
+gem "ruby-vips", require: false
+
+# Test
+gem "minitest", require: false
+gem "minitest-stub-const", require: false
+gem "simplecov", require: false
+
+# Capybara Server
+gem "puma", require: false
+
+# Capybara Drivers
+gem "cuprite", require: false
+gem "selenium-webdriver", require: false
+gem "webdrivers", require: false
+
+group :tools do
+  gem "standard", require: false
+end

data/lib/capybara/screenshot/diff.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require 'capybara/dsl'
-require 'capybara/screenshot/diff/version'
-require 'capybara/screenshot/diff/image_compare'
-require 'capybara/screenshot/diff/test_methods'
+require "capybara/dsl"
+require "capybara/screenshot/diff/version"
+require "capybara/screenshot/diff/drivers/utils"
+require "capybara/screenshot/diff/image_compare"
+require "capybara/screenshot/diff/test_methods"
 
 module Capybara
   module Screenshot
@@ -13,12 +14,17 @@ module Screenshot
     mattr_accessor :blur_active_element
     mattr_accessor :enabled
     mattr_accessor :hide_caret
-    mattr_accessor(:root) { (defined?(Rails.root) && Rails.root) || File.expand_path('.') }
+    mattr_reader(:root) { (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(:save_path) { "doc/screenshots" }
+    mattr_accessor(:use_lfs)
 
     class << self
+      def root=(path)
+        @@root = Pathname(path).expand_path
+      end
+
       def active?
         enabled || (enabled.nil? && Diff.enabled)
       end
@@ -31,7 +37,7 @@ def screenshot_area
       end
 
       def screenshot_area_abs
-        "#{root}/#{screenshot_area}"
+        root / screenshot_area
       end
     end
 
@@ -45,20 +51,24 @@ module Diff
       mattr_accessor(:enabled) { true }
       mattr_accessor :shift_distance_limit
       mattr_accessor :skip_area
+      mattr_accessor(:driver) { :auto }
+      mattr_accessor(:tolerance) { 0.001 }
+
+      AVAILABLE_DRIVERS = Utils.detect_available_drivers.freeze
 
-      def self.included(clas)
-        clas.include TestMethods
-        clas.setup do
+      def self.included(klass)
+        klass.include TestMethods
+        klass.setup do
           if Capybara::Screenshot.window_size
-            if selenium?
-              page.driver.browser.manage.window.resize_to(*Capybara::Screenshot.window_size)
-            elsif poltergeist?
+            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
         end
 
-        clas.teardown do
+        klass.teardown do
           if Capybara::Screenshot::Diff.enabled && @test_screenshots
             test_screenshot_errors = @test_screenshots
               .map { |caller, name, compare| assert_image_not_changed(caller, name, compare) }

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

@@ -0,0 +1,355 @@
+# frozen_string_literal: true
+
+require "chunky_png"
+
+module Capybara
+  module Screenshot
+    module Diff
+      # Compare two images and determine if they are equal, different, or within some comparison
+      # range considering color values and difference area size.
+      module Drivers
+        class ChunkyPNGDriver
+          include ChunkyPNG::Color
+
+          attr_reader :new_file_name, :old_file_name
+
+          def initialize(new_file_name, old_file_name = nil, **options)
+            @new_file_name = new_file_name
+            @old_file_name = old_file_name || "#{new_file_name}~"
+
+            @color_distance_limit = options[:color_distance_limit]
+            @shift_distance_limit = options[:shift_distance_limit]
+            @skip_area = options[:skip_area]
+
+            reset
+          end
+
+          # Resets the calculated data about the comparison with regard to the "new_image".
+          # Data about the original image is kept.
+          def reset
+            @max_color_distance = @color_distance_limit ? 0 : nil
+            @max_shift_distance = @shift_distance_limit ? 0 : nil
+          end
+
+          def load_images(old_file_name, new_file_name)
+            old_bytes, new_bytes = load_image_files(old_file_name, new_file_name)
+
+            _load_images(old_bytes, new_bytes)
+          end
+
+          def filter_image_with_median(_image)
+            raise NotImplementedError
+          end
+
+          def add_black_box(image, _region)
+            image
+          end
+
+          def difference_level(_diff_mask, old_img, region)
+            size(region).to_f / image_area_size(old_img)
+          end
+
+          def image_area_size(old_img)
+            width_for(old_img) * height_for(old_img)
+          end
+
+          def shift_distance_equal?
+            # Stub
+            false
+          end
+
+          def shift_distance_different?
+            # Stub
+            true
+          end
+
+          def find_difference_region(new_image, old_image, color_distance_limit, shift_distance_limit, area_size_limit, fast_fail: false)
+            return nil, nil if new_image.pixels == old_image.pixels
+
+            if fast_fail && !(color_distance_limit || shift_distance_limit || area_size_limit)
+              return [0, 0, width_for(new_image), height_for(new_image)], nil
+            end
+
+            region = find_top(old_image, new_image)
+            region = if region.nil? || region[1].nil?
+              nil
+            else
+              find_diff_rectangle(old_image, new_image, region)
+            end
+
+            [region, nil]
+          end
+
+          def height_for(image)
+            image.height
+          end
+
+          def width_for(image)
+            image.width
+          end
+
+          def size(region)
+            return 0 unless region
+
+            (region[2] - region[0] + 1) * (region[3] - region[1] + 1)
+          end
+
+          def max_color_distance
+            calculate_metrics unless @max_color_distance
+            @max_color_distance
+          end
+
+          def max_shift_distance
+            calculate_metrics unless @max_shift_distance || !@shift_distance_limit
+            @max_shift_distance
+          end
+
+          def adds_error_details_to(log)
+            max_color_distance = self.max_color_distance.ceil(1)
+            max_shift_distance = self.max_shift_distance
+
+            log[:max_color_distance] = max_color_distance
+            log.merge!(max_shift_distance: max_shift_distance) if max_shift_distance
+          end
+
+          def crop(dimensions, i)
+            i.crop(0, 0, *dimensions)
+          end
+
+          def from_file(filename)
+            ChunkyPNG::Image.from_file(filename)
+          end
+
+          # private
+
+          def calculate_metrics
+            old_file, new_file = load_image_files(@old_file_name, @new_file_name)
+
+            if old_file == new_file
+              @max_color_distance = 0
+              @max_shift_distance = 0
+              return
+            end
+
+            old_image, new_image = _load_images(old_file, new_file)
+            calculate_max_color_distance(new_image, old_image)
+            calculate_max_shift_limit(new_image, old_image)
+          end
+
+          def calculate_max_color_distance(new_image, old_image)
+            pixel_pairs = old_image.pixels.zip(new_image.pixels)
+            @max_color_distance = pixel_pairs.inject(0) { |max, (p1, p2)|
+              next max unless p1 && p2
+
+              d = ChunkyPNG::Color.euclidean_distance_rgba(p1, p2)
+              [max, d].max
+            }
+          end
+
+          def calculate_max_shift_limit(new_img, old_img)
+            (0...new_img.width).each do |x|
+              (0...new_img.height).each do |y|
+                shift_distance =
+                  shift_distance_at(new_img, old_img, x, y, color_distance_limit: @color_distance_limit)
+                if shift_distance && (@max_shift_distance.nil? || shift_distance > @max_shift_distance)
+                  @max_shift_distance = shift_distance
+                  return if @max_shift_distance == Float::INFINITY # rubocop: disable Lint/NonLocalExitFromIterator
+                end
+              end
+            end
+          end
+
+          def save_image_to(image, filename)
+            image.save(filename)
+          end
+
+          def resize_image_to(image, new_width, new_height)
+            image.resample_bilinear(new_width, new_height)
+          end
+
+          def load_image_files(old_file_name, file_name)
+            old_file = File.binread(old_file_name)
+            new_file = File.binread(file_name)
+            [old_file, new_file]
+          end
+
+          def dimension_changed?(old_image, new_image)
+            return unless old_image.dimension != new_image.dimension
+
+            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
+          end
+
+          def draw_rectangles(images, (left, top, right, bottom), (r, g, b))
+            images.map do |image|
+              new_img = image.dup
+              new_img.rect(left - 1, top - 1, right + 1, bottom + 1, ChunkyPNG::Color.rgb(r, g, b))
+              new_img
+            end
+          end
+
+          private
+
+          def find_diff_rectangle(org_img, new_img, region)
+            left, top, right, bottom = find_left_right_and_top(org_img, new_img, region)
+            bottom = find_bottom(org_img, new_img, left, right, bottom)
+            [left, top, right, bottom]
+          end
+
+          def find_top(old_img, new_img)
+            old_img.height.times do |y|
+              old_img.width.times do |x|
+                return [x, y, x, y] unless same_color?(old_img, new_img, x, y)
+              end
+            end
+            nil
+          end
+
+          def find_left_right_and_top(old_img, new_img, region)
+            left = region[0] || old_img.width - 1
+            top = region[1]
+            bottom = region[2]
+            right = region[3] || 0
+            old_img.height.times do |y|
+              (0...left).find do |x|
+                next if same_color?(old_img, new_img, x, y)
+
+                top ||= y
+                bottom = y
+                left = x
+                right = x if x > right
+                x
+              end
+              (old_img.width - 1).step(right + 1, -1).find do |x|
+                unless same_color?(old_img, new_img, x, y)
+                  bottom = y
+                  right = x
+                end
+              end
+            end
+            [left, top, right, bottom]
+          end
+
+          def find_bottom(old_img, new_img, left, right, bottom)
+            if bottom
+              (old_img.height - 1).step(bottom + 1, -1).find do |y|
+                (left..right).find do |x|
+                  bottom = y unless same_color?(old_img, new_img, x, y)
+                end
+              end
+            end
+            bottom
+          end
+
+          def same_color?(old_img, new_img, x, y)
+            @skip_area&.each do |skip_start_x, skip_start_y, skip_end_x, skip_end_y|
+              return true if skip_start_x <= x && x <= skip_end_x && skip_start_y <= y && y <= skip_end_y
+            end
+
+            color_distance =
+              color_distance_at(new_img, old_img, x, y, shift_distance_limit: @shift_distance_limit)
+            if !@max_color_distance || color_distance > @max_color_distance
+              @max_color_distance = color_distance
+            end
+            color_matches = color_distance == 0 || (@color_distance_limit && @color_distance_limit > 0 &&
+              color_distance <= @color_distance_limit)
+            return color_matches if !@shift_distance_limit || @max_shift_distance == Float::INFINITY
+
+            shift_distance = (color_matches && 0) ||
+              shift_distance_at(new_img, old_img, x, y, color_distance_limit: @color_distance_limit)
+            if shift_distance && (@max_shift_distance.nil? || shift_distance > @max_shift_distance)
+              @max_shift_distance = shift_distance
+            end
+            color_matches
+          end
+
+          def color_distance_at(new_img, old_img, x, y, shift_distance_limit:)
+            org_color = old_img[x, y]
+            if shift_distance_limit
+              start_x = [0, x - shift_distance_limit].max
+              end_x = [x + shift_distance_limit, new_img.width - 1].min
+              xs = (start_x..end_x).to_a
+              start_y = [0, y - shift_distance_limit].max
+              end_y = [y + shift_distance_limit, new_img.height - 1].min
+              ys = (start_y..end_y).to_a
+              new_pixels = xs.product(ys)
+              distances = new_pixels.map { |dx, dy|
+                new_color = new_img[dx, dy]
+                ChunkyPNG::Color.euclidean_distance_rgba(org_color, new_color)
+              }
+              distances.min
+            else
+              ChunkyPNG::Color.euclidean_distance_rgba(org_color, new_img[x, y])
+            end
+          end
+
+          def shift_distance_at(new_img, old_img, x, y, color_distance_limit:)
+            org_color = old_img[x, y]
+            shift_distance = 0
+            loop do
+              bounds_breached = 0
+              top_row = y - shift_distance
+              if top_row >= 0 # top
+                ([0, x - shift_distance].max..[x + shift_distance, new_img.width - 1].min).each do |dx|
+                  if color_matches(new_img, org_color, dx, top_row, color_distance_limit)
+                    return shift_distance
+                  end
+                end
+              else
+                bounds_breached += 1
+              end
+              if shift_distance > 0
+                if (x - shift_distance) >= 0 # left
+                  ([0, top_row + 1].max..[y + shift_distance, new_img.height - 2].min)
+                    .each do |dy|
+                    if color_matches(new_img, org_color, x - shift_distance, dy, color_distance_limit)
+                      return shift_distance
+                    end
+                  end
+                else
+                  bounds_breached += 1
+                end
+                if (y + shift_distance) < new_img.height # bottom
+                  ([0, x - shift_distance].max..[x + shift_distance, new_img.width - 1].min).each do |dx|
+                    if color_matches(new_img, org_color, dx, y + shift_distance, color_distance_limit)
+                      return shift_distance
+                    end
+                  end
+                else
+                  bounds_breached += 1
+                end
+                if (x + shift_distance) < new_img.width # right
+                  ([0, top_row + 1].max..[y + shift_distance, new_img.height - 2].min)
+                    .each do |dy|
+                    if color_matches(new_img, org_color, x + shift_distance, dy, color_distance_limit)
+                      return shift_distance
+                    end
+                  end
+                else
+                  bounds_breached += 1
+                end
+              end
+              break if bounds_breached == 4
+
+              shift_distance += 1
+            end
+            Float::INFINITY
+          end
+
+          def color_matches(new_img, org_color, x, y, color_distance_limit)
+            new_color = new_img[x, y]
+            return new_color == org_color unless color_distance_limit
+
+            color_distance = ChunkyPNG::Color.euclidean_distance_rgba(org_color, new_color)
+            color_distance <= color_distance_limit
+          end
+
+          def _load_images(old_file, new_file)
+            [ChunkyPNG::Image.from_blob(old_file), ChunkyPNG::Image.from_blob(new_file)]
+          end
+        end
+      end
+    end
+  end
+end