capybara-screenshot-diff 1.6.3 → 1.8.3

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

@@ -2,37 +2,17 @@
 
 require "chunky_png"
 
+require "capybara/screenshot/diff/drivers/base_driver"
+
 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
+        class ChunkyPNGDriver < BaseDriver
           include ChunkyPNG::Color
 
-          attr_reader :new_file_name, :old_file_name
-
-          def initialize(new_file_name, old_file_name = nil, options = {})
-            options = old_file_name if old_file_name.is_a?(Hash)
-
-            @new_file_name = new_file_name
-            @old_file_name = old_file_name || "#{new_file_name}#{ImageCompare::TMP_FILE_SUFFIX}"
-
-            @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)
 
@@ -47,308 +27,269 @@ module Capybara
             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)
+          def find_difference_region(comparison)
+            DifferenceRegionFinder.new(comparison, self).perform
           end
 
-          def shift_distance_equal?
-            # Stub
-            false
+          def crop(region, i)
+            i.crop(*region.to_top_left_corner_coordinates)
           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]
+          def from_file(filename)
+            ChunkyPNG::Image.from_file(filename.to_s)
           end
 
-          def height_for(image)
-            image.height
+          def save_image_to(image, filename)
+            image.save(filename)
           end
 
-          def width_for(image)
-            image.width
+          def resize_image_to(image, new_width, new_height)
+            image.resample_bilinear(new_width, new_height)
           end
 
-          def size(region)
-            return 0 unless region
-
-            (region[2] - region[0] + 1) * (region[3] - region[1] + 1)
+          def load_image_files(old_file_name, file_name)
+            [File.binread(old_file_name), File.binread(file_name)]
           end
 
-          def max_color_distance
-            calculate_metrics unless @max_color_distance
-            @max_color_distance
-          end
+          def draw_rectangles(images, region, (r, g, b), offset: 0)
+            border_color = ChunkyPNG::Color.rgb(r, g, b)
+            border_shadow = ChunkyPNG::Color.rgba(r, g, b, 100)
 
-          def max_shift_distance
-            calculate_metrics unless @max_shift_distance || !@shift_distance_limit
-            @max_shift_distance
+            images.map do |image|
+              new_img = image.dup
+              new_img.rect(region.left - offset, region.top - offset, region.right + offset, region.bottom + offset, border_color)
+              new_img.rect(region.left, region.top, region.right, region.bottom, border_shadow)
+              new_img
+            end
           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
+          def same_pixels?(comparison)
+            comparison.new_image == comparison.base_image
           end
 
-          def crop(dimensions, i)
-            i.crop(*dimensions)
-          end
+          private
 
-          def from_file(filename)
-            ChunkyPNG::Image.from_file(filename)
+          def _load_images(old_file, new_file)
+            [ChunkyPNG::Image.from_blob(old_file), ChunkyPNG::Image.from_blob(new_file)]
           end
 
-          # private
+          class DifferenceRegionFinder
+            attr_accessor :skip_area, :color_distance_limit, :shift_distance_limit
 
-          def calculate_metrics
-            old_file, new_file = load_image_files(@old_file_name, @new_file_name)
+            def initialize(comparison, driver = nil)
+              @comparison = comparison
+              @driver = driver
 
-            if old_file == new_file
-              @max_color_distance = 0
-              @max_shift_distance = 0
-              return
+              @color_distance_limit = comparison.options[:color_distance_limit]
+              @shift_distance_limit = comparison.options[:shift_distance_limit]
+              @skip_area = comparison.options[:skip_area]
             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) if @shift_distance_limit
-          end
+            def perform
+              find_difference_region(@comparison)
+            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
+            def find_difference_region(comparison)
+              new_image, base_image, = comparison.new_image, comparison.base_image
 
-              d = ChunkyPNG::Color.euclidean_distance_rgba(p1, p2)
-              [max, d].max
-            }
-          end
+              meta = {}
+              meta[:max_color_distance] = 0
+              meta[:max_shift_distance] = 0 if shift_distance_limit
 
-          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
+              region = find_top(base_image, new_image, cache: meta)
+              region = if region.nil? || region[1].nil?
+                nil
+              else
+                find_diff_rectangle(base_image, new_image, region, cache: meta)
               end
-            end
-          end
 
-          def save_image_to(image, filename)
-            image.save(filename)
-          end
+              result = Difference.new(region, meta, comparison)
 
-          def resize_image_to(image, new_width, new_height)
-            image.resample_bilinear(new_width, new_height)
-          end
+              unless result.blank?
+                meta[:max_color_distance] = meta[:max_color_distance].ceil(1) if meta[:max_color_distance]
 
-          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
+                if comparison.options[:tolerance]
+                  meta[:difference_level] = difference_level(nil, base_image, region)
+                end
+              end
 
-          def dimension_changed?(old_image, new_image)
-            return unless old_image.dimension != new_image.dimension
+              result
+            end
 
-            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 difference_level(_diff_mask, base_image, region)
+              image_area_size = @driver.image_area_size(base_image)
+              return nil if image_area_size.zero?
 
-          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
+              region.size.to_f / image_area_size
             end
-          end
 
-          private
+            def find_diff_rectangle(org_img, new_img, area_coordinates, cache:)
+              left, top, right, bottom = find_left_right_and_top(org_img, new_img, area_coordinates, cache: cache)
+              bottom = find_bottom(org_img, new_img, left, right, bottom, cache: cache)
 
-          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
+              Region.from_edge_coordinates(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)
+            def find_top(old_img, new_img, cache:)
+              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, cache: cache)
+                end
               end
+              nil
             end
-            nil
-          end
 
-          def find_left_right_and_top(old_img, new_img, region)
-            left = region[0] || old_img.width - 1
-            top = region[1]
-            right = region[2] || 0
-            bottom = region[3]
-            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)
+            def find_left_right_and_top(old_img, new_img, region, cache:)
+              region = region.is_a?(Region) ? region.to_edge_coordinates : region
+
+              left = region[0] || old_img.width - 1
+              top = region[1]
+              right = region[2] || 0
+              bottom = region[3]
+
+              old_img.height.times do |y|
+                (0...left).find do |x|
+                  next if same_color?(old_img, new_img, x, y, cache: cache)
+
+                  top ||= y
                   bottom = y
-                  right = x
+                  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, cache: cache)
+                    bottom = y
+                    right = x
+                  end
                 end
               end
+
+              [left, top, right, bottom]
             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)
+            def find_bottom(old_img, new_img, left, right, bottom, cache:)
+              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, cache: cache)
+                  end
                 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
+              bottom
             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
+            def same_color?(old_img, new_img, x, y, cache:)
+              return true if skipped_region?(x, y)
+
+              color_distance =
+                color_distance_at(new_img, old_img, x, y, shift_distance_limit: @shift_distance_limit)
+
+              if color_distance > cache[:max_color_distance]
+                cache[: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 || cache[: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 && (cache[:max_shift_distance].nil? || shift_distance > cache[:max_shift_distance])
+                cache[:max_shift_distance] = shift_distance
+              end
+
+              color_matches
             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])
+            def skipped_region?(x, y)
+              return false unless @skip_area
+
+              @skip_area.any? { |region| region.cover?(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
+            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 do |dx, dy|
+                  ChunkyPNG::Color.euclidean_distance_rgba(org_color, new_img[dx, dy])
                 end
+                distances.min
               else
-                bounds_breached += 1
+                ChunkyPNG::Color.euclidean_distance_rgba(org_color, new_img[x, y])
               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)
+            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 (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
+                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
-                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
+                  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
-                else
-                  bounds_breached += 1
                 end
-              end
-              break if bounds_breached == 4
+                break if bounds_breached == 4
 
-              shift_distance += 1
+                shift_distance += 1
+              end
+              Float::INFINITY
             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 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
 
-          def _load_images(old_file, new_file)
-            [ChunkyPNG::Image.from_blob(old_file), ChunkyPNG::Image.from_blob(new_file)]
+              color_distance = ChunkyPNG::Color.euclidean_distance_rgba(org_color, new_color)
+              color_distance <= color_distance_limit
+            end
           end
         end
       end

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

@@ -10,15 +10,33 @@ module Capybara
             result << :vips if defined?(Vips) || require("vips")
           rescue LoadError
             # vips not present
+            Object.send(:remove_const, :Vips) if defined?(Vips)
           end
           begin
             result << :chunky_png if defined?(ChunkyPNG) || require("chunky_png")
           rescue LoadError
             # chunky_png not present
+            Object.send(:remove_const, :ChunkyPNG) if defined?(ChunkyPNG)
           end
           result
         end
 
+        def self.find_driver_class_for(driver)
+          driver = AVAILABLE_DRIVERS.first if driver == :auto
+
+          LOADED_DRIVERS[driver] ||=
+            case driver
+            when :chunky_png
+              require "capybara/screenshot/diff/drivers/chunky_png_driver"
+              Drivers::ChunkyPNGDriver
+            when :vips
+              require "capybara/screenshot/diff/drivers/vips_driver"
+              Drivers::VipsDriver
+            else
+              fail "Wrong adapter #{driver.inspect}. Available adapters: #{AVAILABLE_DRIVERS.inspect}"
+            end
+        end
+
         def self.detect_test_framework_assert
           require "minitest"
           ::Minitest::Assertion