capybara-screenshot-diff 1.7.1 → 1.8.1

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

@@ -3,11 +3,11 @@
 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
 
-require_relative "./chunky_png_driver"
+require "capybara/screenshot/diff/drivers/base_driver"
 
 module Capybara
   module Screenshot
@@ -15,67 +15,33 @@ 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
-        class VipsDriver
-          attr_reader :new_file_name, :old_file_name, :options
+        class VipsDriver < BaseDriver
+          def find_difference_region(comparison)
+            new_image, base_image, options = comparison.new_image, comparison.base_image, comparison.options
 
-          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}"
-
-            @options = options || {}
-
-            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
-          end
-
-          def shift_distance_equal?
-            warn "[capybara-screenshot-diff] Instead of shift_distance_limit " \
-                   "please use median_filter_window_size and color_distance_limit options"
-            chunky_png_comparator.quick_equal?
-          end
-
-          def shift_distance_different?
-            warn "[capybara-screenshot-diff] Instead of shift_distance_limit " \
-                   "please use median_filter_window_size and color_distance_limit options"
-            chunky_png_comparator.different?
-          end
-
-          def find_difference_region(new_image, old_image, color_distance_limit, _shift_distance_limit, _area_size_limit, fast_fail: false)
-            diff_mask = VipsUtil.difference_mask(color_distance_limit, old_image, new_image)
+            diff_mask = VipsUtil.difference_mask(base_image, new_image, options[:color_distance_limit])
             region = VipsUtil.difference_region_by(diff_mask)
+            region = nil if region && same_as?(region, base_image)
 
-            [region, diff_mask]
-          end
-
-          def adds_error_details_to(_log)
-          end
+            result = Difference.new(region, {}, comparison)
 
-          # old private
+            unless result.blank?
+              meta = {}
+              meta[:difference_level] = difference_level(diff_mask, base_image) if comparison.options[:tolerance]
+              result.meta = meta
+            end
 
-          def inscribed?(dimensions, i)
-            dimension(i) == dimensions || i.width < dimensions[0] || i.height < dimensions[1]
+            result
           end
 
           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
+            i.crop(*region.to_top_left_corner_coordinates)
+          rescue Vips::Error => e
+            warn(
+              "[capybara-screenshot-diff] Crop has been failed for " \
+              "{ region: #{region.to_top_left_corner_coordinates.inspect}, image: #{dimension(i).join("x")} }"
+            )
+            raise e
           end
 
           def filter_image_with_median(image, median_filter_window_size)
@@ -86,84 +52,66 @@ module Capybara
             memo.draw_rect([0, 0, 0, 0], *region.to_top_left_corner_coordinates, fill: true)
           end
 
-          def chunky_png_comparator
-            @chunky_png_comparator ||= ImageCompare.new(
-              @new_file_name,
-              @old_file_name,
-              **@options.merge(driver: :chunky_png, tolerance: nil, median_filter_window_size: nil)
-            )
-          end
-
           def difference_level(diff_mask, old_img, _region = nil)
             VipsUtil.difference_area_size_by(diff_mask).to_f / image_area_size(old_img)
           end
 
-          def image_area_size(old_img)
-            width_for(old_img) * height_for(old_img)
-          end
-
-          def height_for(image)
-            image.height
-          end
-
-          def width_for(image)
-            image.width
-          end
-
-          PNG_EXTENSION = ".png"
+          MAX_FILENAME_LENGTH = 200
 
           # Vips could not work with the same file. Per each process we require to create new file
           def save_image_to(image, filename)
-            ::Dir::Tmpname.create([filename, PNG_EXTENSION]) do |tmp_image_filename|
+            # Dir::Tmpname will happily produce tempfile names that are too long for most unix filesystems,
+            # which leads to "unix error: File name too long". Apply a limit to avoid this.
+            limited_filename = filename.to_s[-MAX_FILENAME_LENGTH..] || filename.to_s
+            ::Dir::Tmpname.create([limited_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)
-            image.resize(1.* new_width / new_height)
+            image.resize(new_width.to_f / new_height)
           end
 
-          def load_images(old_file_name, new_file_name, driver = self)
-            [driver.from_file(old_file_name), driver.from_file(new_file_name)]
+          def load_images(old_file_name, new_file_name)
+            [from_file(old_file_name), from_file(new_file_name)]
           end
 
           def from_file(filename)
-            result = ::Vips::Image.new_from_file(filename)
+            result = ::Vips::Image.new_from_file(filename.to_s)
 
-            result = result.colourspace("srgb") if result.bands < 3
+            result = result.colourspace(:srgb) if result.bands < 3
             result = result.bandjoin(255) if result.bands == 3
 
             result
           end
 
-          def dimension_changed?(old_image, new_image)
-            return false if dimension(old_image) == dimension(new_image)
-
-            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 dimension(image)
-            [image.width, image.height]
+            [width_for(image), height_for(image)]
           end
 
-          def draw_rectangles(images, region, rgba)
+          def draw_rectangles(images, region, rgba, offset: 0)
             images.map do |image|
-              image.draw_rect(rgba, region.left - 1, region.top - 1, region.width + 2, region.height + 2)
+              image.draw_rect(rgba, region.left - offset, region.top - offset, region.width + (offset * 2), region.height + (offset * 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).to_edge_coordinates
-            end
+          def same_pixels?(comparison)
+            (comparison.new_image == comparison.base_image).min == 255
+          end
 
+          private
+
+          def same_as?(region, base_image)
+            region.x.zero? &&
+              region.y.zero? &&
+              region.height == height_for(base_image) &&
+              region.width == width_for(base_image)
+          end
+
+          class VipsUtil
             def self.difference_area(old_image, new_image, color_distance: 0)
-              difference_mask = difference_mask(color_distance, new_image, old_image)
+              difference_mask = difference_mask(new_image, old_image, color_distance)
               difference_area_size_by(difference_mask)
             end
 
@@ -172,18 +120,20 @@ module Capybara
               diff_mask.hist_find.to_a[0][0].max
             end
 
-            def self.difference_mask(color_distance, old_image, new_image)
-              (new_image - old_image).abs > color_distance
+            def self.difference_mask(base_image, new_image, color_distance = nil)
+              result = (new_image - base_image).abs
+
+              color_distance ? result > color_distance : result
             end
 
             def self.difference_region_by(diff_mask)
               columns, rows = diff_mask.bandor.project
 
               left = columns.profile[1].min
-              right = columns.width - columns.flip("horizontal").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
+              bottom = rows.height - rows.flip(:vertical).profile[0].min
 
               return nil if right < left || bottom < top
 

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Screenshot
+    module Diff
+      module Drivers
+        def self.for(driver_options = {})
+          driver_option = driver_options.fetch(:driver, :chunky_png)
+          return driver_option unless driver_option.is_a?(Symbol)
+
+          Utils.find_driver_class_for(driver_option).new
+        end
+      end
+    end
+  end
+end

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

@@ -5,211 +5,186 @@ module Capybara
     module Diff
       LOADED_DRIVERS = {}
 
-      # Compare two images and determine if they are equal, different, or within some comparison
+      # Compare two image and determine if they are equal, different, or within some comparison
       # range considering color values and difference area size.
-      class ImageCompare < SimpleDelegator
-        TMP_FILE_SUFFIX = "~"
+      class ImageCompare
+        TOLERABLE_OPTIONS = [:tolerance, :color_distance_limit, :shift_distance_limit, :area_size_limit].freeze
 
         attr_reader :driver, :driver_options
 
-        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
+        attr_reader :annotated_image_path, :annotated_base_image_path,
+          :image_path, :base_image_path,
+          :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)
+        def initialize(image_path, base_image_path, options = {})
+          @image_path = Pathname.new(image_path)
 
-          @new_file_name = new_file_name
-          @old_file_name = old_file_name || "#{new_file_name}#{ImageCompare::TMP_FILE_SUFFIX}"
-          @annotated_old_file_name = "#{new_file_name.chomp(".png")}.committed.png"
-          @annotated_new_file_name = "#{new_file_name.chomp(".png")}.latest.png"
+          @new_file_name = @image_path.to_s
+          @annotated_image_path = @image_path.sub_ext(".diff.png")
 
-          @driver_options = options
+          @base_image_path = Pathname.new(base_image_path)
 
-          @color_distance_limit = options[:color_distance_limit] || 0
-          @area_size_limit = options[:area_size_limit]
-          @shift_distance_limit = options[:shift_distance_limit]
-          @dimensions = options[:dimensions]
-          @skip_area = options[:skip_area]
-          @tolerance = options[:tolerance]
-          @median_filter_window_size = options[:median_filter_window_size]
+          @old_file_name = @base_image_path.to_s
+          @annotated_base_image_path = @base_image_path.sub_ext(".diff.png")
 
-          driver_klass = find_driver_class_for(@driver_options.fetch(:driver, :chunky_png))
-          @driver = driver_klass.new(@new_file_name, @old_file_name, **@driver_options)
+          @driver_options = options.dup
 
-          super(@driver)
-        end
-
-        def skip_area=(new_skip_area)
-          @skip_area = new_skip_area
-          driver.skip_area = @skip_area
+          @driver = Drivers.for(@driver_options)
         end
 
         # 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?
-          return false unless old_file_exists?
+          @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
           return true if new_file_size == old_file_size
 
-          images = driver.load_images(@old_file_name, @new_file_name)
-          old_image, new_image = preprocess_images(images, driver)
+          comparison = load_and_process_images
 
-          return false if driver.dimension_changed?(old_image, new_image)
+          unless driver.same_dimension?(comparison)
+            @error_message = build_error_for_different_dimensions(comparison)
+            return false
+          end
 
-          self.difference_region, meta = driver.find_difference_region(
-            new_image,
-            old_image,
-            @color_distance_limit,
-            @shift_distance_limit,
-            @area_size_limit,
-            fast_fail: true
-          )
+          return true if driver.same_pixels?(comparison)
 
-          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?
+          # 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?
+
+          @error_message = @difference.inspect
           false
         end
 
-        # Compare the two images referenced by this object, and return `true` if they are different,
+        # Compare the two image referenced by this object, and return `true` if they are different,
         # and `false` if they are the same.
         def different?
-          return false unless old_file_exists?
+          @error_message = nil
 
-          images = driver.load_images(@old_file_name, @new_file_name)
-          old_image, new_image = preprocess_images(images, driver)
+          @error_message = _different?
 
-          if driver.dimension_changed?(old_image, new_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
-            )
+          clean_tmp_files unless @error_message
 
-            return different(*images)
-          end
+          !@error_message.nil?
+        end
+
+        def build_error_for_different_dimensions(comparison)
+          change_msg = [comparison.base_image, comparison.new_image]
+            .map { |i| driver.dimension(i).join("x") }
+            .join(" => ")
 
-          self.difference_region, meta = driver.find_difference_region(
-            new_image,
-            old_image,
-            @color_distance_limit,
-            @shift_distance_limit,
-            @area_size_limit
-          )
-
-          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?
-
-          different(*images)
+          "Screenshot dimension has been changed for #{@new_file_name}: #{change_msg}"
         end
 
         def clean_tmp_files
-          FileUtils.cp @old_file_name, @new_file_name if old_file_exists?
-          File.delete(@old_file_name) if old_file_exists?
-          File.delete(@annotated_old_file_name) if File.exist?(@annotated_old_file_name)
-          File.delete(@annotated_new_file_name) if File.exist?(@annotated_new_file_name)
+          @annotated_base_image_path.unlink if @annotated_base_image_path.exist?
+          @annotated_image_path.unlink if @annotated_image_path.exist?
         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)
+        def save(image, image_path)
+          driver.save_image_to(image, image_path.to_s)
         end
 
-        def old_file_exists?
-          @old_file_name && File.exist?(@old_file_name)
+        def image_files_exist?
+          @base_image_path.exist? && @image_path.exist?
         end
 
-        def reset
-          self.difference_region = nil
-          driver.reset
+        NEW_LINE = "\n"
+
+        attr_reader :error_message
+
+        private
+
+        def without_tolerable_options?
+          (@driver_options.keys & TOLERABLE_OPTIONS).empty?
         end
 
-        NEW_LINE = "\n"
+        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 error_message
-          result = {
-            area_size: difference_region_area_size,
-            region: difference_coordinates
-          }
+          comparison = load_and_process_images
 
-          driver.adds_error_details_to(result)
+          unless driver.same_dimension?(comparison)
+            return build_error_for_different_dimensions(comparison)
+          end
+
+          return not_different if driver.same_pixels?(comparison)
 
+          @difference = driver.find_difference_region(comparison)
+          return not_different unless @difference.different?
+
+          different(@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)
+        end
+
+        def build_error_message(difference)
           [
-            "(#{result.to_json})",
+            "(#{difference.inspect})",
             new_file_name,
-            annotated_old_file_name,
-            annotated_new_file_name
+            annotated_base_image_path.to_path,
+            annotated_image_path.to_path
           ].join(NEW_LINE)
         end
 
-        def difference_coordinates
-          difference_region&.to_edge_coordinates
+        def skip_area
+          @driver_options[:skip_area]
         end
 
-        def difference_region_area_size
-          return 0 unless difference_region
-
-          difference_region.size
+        def median_filter_window_size
+          @driver_options[:median_filter_window_size]
         end
 
-        private
-
-        attr_accessor :difference_region
-
-        def different(old_image, new_image)
-          annotate_and_save([old_image, new_image], difference_region)
-          true
+        def dimensions
+          @driver_options[:dimensions]
         end
 
-        def 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
+        def different(difference)
+          annotate_and_save_images(difference)
+          build_error_message(difference)
         end
 
-        def preprocess_images(images, driver = self)
-          old_img = preprocess_image(images.first, driver)
-          new_img = preprocess_image(images.last, driver)
-
-          [old_img, new_img]
+        def preprocess_images(images)
+          images.map { |image| preprocess_image(image) }
         end
 
-        def preprocess_image(image, driver = self)
+        def preprocess_image(image)
           result = image
 
-          if @dimensions && driver.inscribed?(@dimensions, result)
-            result = driver.crop(@dimensions, result)
+          # 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 @median_filter_window_size
-            result = driver.filter_image_with_median(image, @median_filter_window_size)
+          if skip_area
+            result = ignore_skipped_area(result)
           end
 
-          if @skip_area
-            result = @skip_area.reduce(result) { |image, region| driver.add_black_box(image, region) }
+          if median_filter_window_size
+            result = blur_image_by(image, median_filter_window_size)
           end
 
           result
         end
 
+        def blur_image_by(image, size)
+          driver.filter_image_with_median(image, size)
+        end
+
+        def ignore_skipped_area(image)
+          skip_area.reduce(image) { |memo, region| driver.add_black_box(memo, region) }
+        end
+
         def old_file_size
-          @old_file_size ||= old_file_exists? && File.size(@old_file_name)
+          @old_file_size ||= image_files_exist? && File.size(@old_file_name)
         end
 
         def new_file_size
@@ -217,41 +192,37 @@ module Capybara
         end
 
         def not_different
-          clean_tmp_files
-          false
+          nil
         end
 
-        def difference_region_empty?(new_image, region)
-          region.nil? ||
-            (
-              region.height == height_for(new_image) &&
-                region.width == width_for(new_image) &&
-                region.x.zero? &&
-                region.y.zero?
-            )
+        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)
         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)
+        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(images, region)
-          driver.draw_rectangles(images, region, DIFF_COLOR)
+        def annotate_difference(image, region)
+          driver.draw_rectangles(Array[image], region, DIFF_COLOR, offset: 1).first
         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)
+        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
 end

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

@@ -7,7 +7,7 @@ module Capybara
       ON_MAC = !!(RbConfig::CONFIG["host_os"] =~ /darwin/)
       ON_LINUX = !!(RbConfig::CONFIG["host_os"] =~ /linux/)
 
-      def os_name
+      def self.name
         return "windows" if ON_WINDOWS
         return "macos" if ON_MAC
         return "linux" if ON_LINUX