eyes_images 3.18.3 → 4.0.0.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8bce468b2ca11fbd248c97f90f1202062d7af40e
-  data.tar.gz: 529858601685474e2c3a43cb42eb599ed5f6ef62
+SHA256:
+  metadata.gz: d57304fb9f70a31cdd54d4d858518da1bb743242300cb7f6b44fca409e0ee474
+  data.tar.gz: 0a8912459d6a810501f61c7d33dfa5fb318832ab35d3ef962640b075950e4a72
 SHA512:
-  metadata.gz: 05dff035c169991a5f87011b10c798d5e67d94696b30c4ffd7e7f57bfa8def7ed491e0ff7185680748c823e199f480e17f17cc7f8cd226323ffe5acc5ba6f39c
-  data.tar.gz: 82378f4e97860994d0ac4beff8505dfbbb107ef2f5a722354986a31e62d87a121225d6012594d72b58b3c4bb4aca9d5b977f8380e9c6402920cef5e1aba29114
+  metadata.gz: 026b9ed41e630373d5ce26a269f77a075789e28c5aef3842ccf4b6b07ec60900e8996b4f1fa7be2085be74fc1207f9476039daf5dbd893421b4743277ed55033
+  data.tar.gz: b967d91e24a201491432165860f8c198a0f67ff43fc13b4a941754433c80a175a04c4233710885549360a7dc8964d4729c784395d85b390d29080a5fe6b05b94

data/lib/applitools/images/eyes.rb

@@ -42,7 +42,8 @@ module Applitools::Images
     def open(options = {})
       Applitools::ArgumentGuard.hash options, 'open(options)', [:app_name, :test_name]
       options[:viewport_size] = Applitools::RectangleSize.from_any_argument options[:viewport_size]
-      open_base options
+      # options = Applitools::Utils.extract_options!(args)
+      universal_open(options)
     end
 
     # Opens eyes using passed options, yields the block and then closes eyes session.
@@ -93,6 +94,9 @@ module Applitools::Images
 
     def check_it(name, target, match_window_data)
       Applitools::ArgumentGuard.not_nil(name, 'name')
+
+      return universal_check(name, target)
+
       region_provider = get_region_provider(target)
 
       match_window_data.tag = name
@@ -164,8 +168,8 @@ module Applitools::Images
     #   eyes.check_image(image: my_image, tag: 'My Test', ignore_mismatch: true)
     def check_image(options)
       options = { tag: '', ignore_mismatch: false }.merge options
-      image = get_image_from_options(options)
-      target = Applitools::Images::Target.any(image).ignore_mismatch(options[:ignore_mismatch])
+      # image = get_image_from_options(options)
+      target = Applitools::Images::Target.any(options).ignore_mismatch(options[:ignore_mismatch])
       check(options[:tag], target)
     end
 
@@ -185,10 +189,10 @@ module Applitools::Images
     # @example Image is a +String+
     #   eyes.check_region(image_bytes: string_represents_image, tag: 'My Test', region: my_region)
     def check_region(options)
-      options = { tag: nil, ignore_mismatch: false }.merge options
+      options = { tag: '', ignore_mismatch: false }.merge options
       Applitools::ArgumentGuard.not_nil options[:region], 'options[:region] can\'t be nil!'
-      image = get_image_from_options options
-      target = Applitools::Images::Target.any(image).ignore_mismatch(options[:ignore_mismatch])
+      # image = get_image_from_options options
+      target = Applitools::Images::Target.any(options).ignore_mismatch(options[:ignore_mismatch])
       target.region(options[:region])
       logger.info "check_region(image, #{options[:region]}, #{options[:tag]}, #{options[:ignore_mismatch]})"
       check(options[:tag], target)
@@ -232,22 +236,22 @@ module Applitools::Images
     alias get_viewport_size vp_size
     alias set_viewport_size vp_size=
 
-    def get_image_from_options(options)
-      image = if options[:image].nil? || !options[:image].is_a?(Applitools::Screenshot)
-                if options[:image].is_a? ChunkyPNG::Image
-                  Applitools::Screenshot.from_image options[:image]
-                elsif !options[:image_path].nil? && !options[:image_path].empty?
-                  Applitools::Screenshot.from_datastream ChunkyPNG::Datastream.from_file(options[:image_path]).to_s
-                elsif !options[:image_bytes].nil? && !options[:image_bytes].empty?
-                  Applitools::Screenshot.from_datastream options[:image_bytes]
-                end
-              else
-                options[:image]
-              end
-
-      Applitools::ArgumentGuard.not_nil image, 'options[:image] can\'t be nil!'
-
-      image
-    end
+    # def get_image_from_options(options)
+    #   image = if options[:image].nil? || !options[:image].is_a?(Applitools::Screenshot)
+    #             # if options[:image].is_a? ChunkyPNG::Image
+    #             #   Applitools::Screenshot.from_image options[:image]
+    #             # if !options[:image_path].nil? && !options[:image_path].empty?
+    #             #   Applitools::Screenshot.from_datastream ChunkyPNG::Datastream.from_file(options[:image_path]).to_s
+    #             if !options[:image_bytes].nil? && !options[:image_bytes].empty?
+    #               Applitools::Screenshot.from_datastream options[:image_bytes]
+    #             end
+    #           else
+    #             options[:image]
+    #           end
+    #
+    #   Applitools::ArgumentGuard.not_nil image, 'options[:image] can\'t be nil!'
+    #
+    #   image
+    # end
   end
 end

data/lib/applitools/images/target.rb

@@ -6,19 +6,20 @@ module Applitools::Images
     class << self
       def path(path)
         raise Applitools::EyesIllegalArgument unless File.exist?(path)
-        new Applitools::Screenshot.from_image(ChunkyPNG::Image.from_file(path))
+        # new Applitools::Screenshot.from_image(ChunkyPNG::Image.from_file(path))
+        new(path)
       end
 
       def blob(blob_image)
         Applitools::ArgumentGuard.not_nil blob_image, 'blob_image'
         Applitools::ArgumentGuard.is_a? blob_image, 'blob_image', String
-        new Applitools::Screenshot.from_datastream(blob_image)
+        new(blob_image)
       end
 
       def image(image)
         Applitools::ArgumentGuard.not_nil image, 'image'
-        Applitools::ArgumentGuard.is_a? image, 'image', ChunkyPNG::Image
-        new Applitools::Screenshot.from_image(image)
+        # Applitools::ArgumentGuard.is_a? image, 'image', ChunkyPNG::Image
+        new(image)
       end
 
       def screenshot(screenshot)
@@ -28,28 +29,36 @@ module Applitools::Images
       end
 
       def any(screenshot)
-        case screenshot
-        when Applitools::Screenshot
-          screenshot(screenshot)
-        when ChunkyPNG::Image
-          image(screenshot)
-        when String
-          begin
-            blob(screenshot)
-          rescue ChunkyPNG::SignatureMismatch
-            path(screenshot)
-          end
-        else
-          raise Applitools::EyesIllegalArgument.new "Passed screenshot is not image type (#{screenshot.class})"
-        end
+        new(screenshot)
       end
     end
 
     attr_accessor :image, :options, :ignored_regions, :region_to_check, :floating_regions, :accessibility_regions
 
-    def initialize(image)
+    def convert_image_arg(image_arg)
+      if image_arg.is_a?(Applitools::Screenshot)
+        Base64.strict_encode64(image_arg.to_blob).force_encoding('UTF-8')
+      elsif image_arg.class.name === 'ChunkyPNG::Image'
+        Base64.strict_encode64(image_arg.to_blob).force_encoding('UTF-8')
+      elsif image_arg.is_a?(Hash) && !image_arg[:image_path].nil?
+        image_arg[:image_path]
+      elsif image_arg.is_a?(Hash) && !image_arg[:image].nil?
+        Base64.strict_encode64(image_arg[:image]).force_encoding('UTF-8')
+      elsif image_arg.is_a?(Hash)
+        raise Applitools::EyesIllegalArgument.new "Image is unrecognized, try  to use image_path: path_or_url or image: buffer"
+      elsif image_arg.is_a?(String) && File.exist?(image_arg) # Path
+        image_arg
+      elsif image_arg.is_a?(String) # URL ? Buffer
+        raise Applitools::EyesIllegalArgument.new "Passed image is not explicit, try  to use image_path: path_or_url or image: buffer"
+      else
+        raise Applitools::EyesIllegalArgument.new "Passed image is unrecognized"
+      end
+    end
+
+    def initialize(image_arg)
+      image = convert_image_arg(image_arg)
       Applitools::ArgumentGuard.not_nil(image, 'image')
-      Applitools::ArgumentGuard.is_a? image, 'image', Applitools::Screenshot
+      Applitools::ArgumentGuard.is_a? image, 'image', String
       self.image = image
       self.ignored_regions = []
       self.floating_regions = []
@@ -60,47 +69,67 @@ module Applitools::Images
     end
 
     def ignore(*args)
-      requested_padding = if args.last.is_a? Applitools::PaddingBounds
-                            args.pop
-                          else
-                            Applitools::PaddingBounds::PIXEL_PADDING
-                          end
-      region = args.shift
-      if region
-        Applitools::ArgumentGuard.is_a? region, 'region', Applitools::Region
-        ignored_regions << region.padding(requested_padding)
+      region = region_from_args(args)
+      ignored_regions << region if region
+      self
+    end
+
+    def get_bounds(args)
+      return args.pop.to_hash if args.last.is_a?(Applitools::FloatingBounds)
+      last4 = args.last(4)
+      if last4.size === 4 && last4.all? { |e| e.is_a?(Numeric) }
+        FloatingBounds.new(*last4).to_hash
       else
-        self.ignored_regions = []
+        {}
+      end
+    end
+
+    def region_from_args(args)
+      options = Applitools::Utils.extract_options!(args)
+      padding = options && options[:padding]
+      requested_padding = get_requested_padding(padding, args)
+      value = convert_to_universal(args)
+      value = { type: args[0], selector: args[1] } if value.nil?
+      value = value[:selector] if value.is_a?(Hash) && (value[:type].to_s === 'id')
+      return nil if value === {selector: nil, type: nil}
+      region = { region: value }
+      region.merge!(padding: requested_padding) if requested_padding != {}
+      region.merge!(regionId: options[:region_id]) if options[:region_id]
+      region
+    end
+
+    def get_requested_padding(padding, args)
+      return padding.to_hash if padding && padding.is_a?(Applitools::PaddingBounds)
+      return padding if padding && (padding.is_a?(Hash) || padding.is_a?(Numeric))
+      if args.last.is_a? Applitools::PaddingBounds
+        args.pop
+        # elsif args.last.is_a?(Applitools::FloatingBounds)
+        #   args.pop.to_hash
+      else
+        {}
       end
-      self
     end
 
     def floating(*args)
-      requested_padding = if args.last.is_a? Applitools::PaddingBounds
-                            args.pop
-                          else
-                            Applitools::PaddingBounds::PIXEL_PADDING
-                          end
-
-      value = case args.first
-              when Applitools::FloatingRegion
-                proc { args.first.padding(requested_padding) }
-              when Applitools::Region
-                proc do
-                  region = args.shift
-                  Applitools::FloatingRegion.any(region, *args).padding(requested_padding)
-                end
-              else
-                self.floating_regions = []
-              end
-      floating_regions << value
+      options = Applitools::Utils.extract_options!(args)
+      padding = options && options[:padding]
+      requested_padding = get_requested_padding(padding, args)
+      bounds = get_bounds(args)
+      value = convert_to_universal(args)
+      value = { type: args[0], selector: args[1] } if value.nil?
+      value = value[:selector] if value.is_a?(Hash) && (value[:type].to_s === 'id')
+      region = { region: value }
+      region.merge!(bounds) if bounds != {}
+      region.merge!(padding: requested_padding) if requested_padding != {}
+      region.merge!(regionId: options[:region_id]) if options[:region_id]
+      floating_regions << region
       self
     end
 
     def region(region = nil)
       if region
         Applitools::ArgumentGuard.is_a? region, 'region', Applitools::Region
-        self.region_to_check = region
+        self.region_to_check = region.to_hash
       else
         self.region_to_check = nil
       end
@@ -119,5 +148,60 @@ module Applitools::Images
                                  Applitools::AccessibilityRegion.new(region, accessibility_region_type)
                                end
     end
+
+
+
+    private # dupl
+
+    def is_element?(el)
+      el.is_a?(::Selenium::WebDriver::Element) || (el.is_a?(Applitools::Selenium::Element) && el.respond_to?(:ref))
+    end
+
+    def is_region?(region)
+      region.is_a?(Applitools::FloatingRegion) || region.is_a?(Applitools::Region) # || region.is_a?(Applitools::Selenium::Element)
+    end
+
+    def is_finder?(finders)
+      return false unless finders.is_a?(Array)
+      return false unless finders[1]
+      return true if [:uiautomator, :predicate, :accessibility_id].include?(finders[0].to_sym)
+      Applitools::Selenium::Driver::FINDERS.has_key?(finders[0].to_sym)
+    end
+
+    def convert_to_universal(args)
+      if is_element?(args.first)
+        ref = args.first.ref
+        ref = args.first.ref[1] if ref.is_a?(Array) && ref[0] === :element
+        return { elementId: ref }
+      end
+      return args.first.to_hash if is_region?(args.first)
+      if is_finder?(args)
+        if Applitools::Selenium::Driver::FINDERS.has_key?(args[0])
+          selector = args[1]
+          selector = "##{args[1]}" if args[0] === :id && !args[1].start_with?('#') && instance_of?(Applitools::Selenium::Target)
+          return {type: Applitools::Selenium::Driver::FINDERS[args[0]], selector: selector}
+        end
+        case args[0]
+          when :uiautomator # ANDROID_UI_AUTOMATOR: '-android uiautomator'
+            return {type: '-android uiautomator', selector: args[1]}
+          when :predicate # IOS_PREDICATE: '-ios predicate string',
+            return {type: '-ios predicate string', selector: args[1]}
+          when :accessibility_id
+            return {type: 'accessibility id', selector: args[1]}
+        end
+      end
+      if args.first.is_a?(String)
+        return proc { |driver| driver.find_element(name_or_id: args.first) }
+      end
+      if args.first.is_a?(Hash) && args.first.has_key?('selector')
+        if args.first.has_key?('shadow')
+          return {selector: args.first['selector'], shadow: args.first['shadow']}
+        else
+          return {selector: args.first['selector']}
+        end
+      end
+      nil
+    end
+
   end
 end

data/lib/applitools/version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: false
 
 module Applitools
-  VERSION = '3.18.3'.freeze
+  VERSION = '4.5.0.beta'.freeze
+  IMAGES_VERSION = '4.0.0.alpha'.freeze
+  UNIVERSAL_VERSION = '3.0.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_images
 version: !ruby/object:Gem::Version
-  version: 3.18.3
+  version: 4.0.0.alpha
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-24 00:00:00.000000000 Z
+date: 2022-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eyes_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.18.3
+        version: 4.5.0.beta
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.18.3
+        version: 4.5.0.beta
 description: Provides Images SDK for Applitools tests.
 email:
 - team@applitools.com
@@ -32,7 +32,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/applitools/images/eyes.rb
-- lib/applitools/images/eyes_images_screenshot.rb
 - lib/applitools/images/target.rb
 - lib/applitools/version.rb
 - lib/eyes_images.rb
@@ -52,12 +51,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14.3
+rubygems_version: 3.3.14
 signing_key: 
 specification_version: 4
 summary: Applitools Ruby Images SDK

data/lib/applitools/images/eyes_images_screenshot.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module Applitools::Images
-  # @!visibility private
-  class EyesImagesScreenshot < ::Applitools::EyesScreenshot
-    SCREENSHOT_AS_IS = Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is].freeze
-    CONTEXT_RELATIVE = Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative].freeze
-
-    def initialize(image, options = {})
-      super image
-      return if (location = options[:location]).nil?
-      Applitools::ArgumentGuard.is_a? location, 'options[:location]', Applitools::Location
-      @bounds = Applitools::Region.new location.x, location.y, image.width, image.height
-    end
-
-    def convert_location(location, from, to)
-      Applitools::ArgumentGuard.not_nil location, 'location'
-      Applitools::ArgumentGuard.not_nil from, 'from'
-      Applitools::ArgumentGuard.not_nil to, 'to'
-
-      Applitools::ArgumentGuard.is_a? location, 'location', Applitools::Location
-
-      result = Applitools::Location.new location.x, location.y
-      return result if from == to
-
-      case from
-      when SCREENSHOT_AS_IS
-        raise "Coordinate type conversation error: #{from} -> #{to}" unless to == CONTEXT_RELATIVE
-        result.offset bounds
-        return result
-      when CONTEXT_RELATIVE
-        raise "Coordinate type conversation error: #{from} -> #{to}" unless to == SCREENSHOT_AS_IS
-        result.offset(Applitools::Location.new(-bounds.x, -bounds.y))
-        return result
-      else
-        raise "Coordinate type conversation error: #{from} -> #{to}"
-      end
-    end
-
-    def intersected_region(region, from, to = CONTEXT_RELATIVE)
-      Applitools::ArgumentGuard.not_nil region, 'region'
-      Applitools::ArgumentGuard.not_nil from, 'coordinates Type (from)'
-
-      return Applitools::Region.new(0, 0, 0, 0) if region.empty?
-
-      intersected_region = convert_region_location region, from, to
-      intersected_region.intersect bounds
-      return intersected_region if intersected_region.empty?
-
-      intersected_region.location = convert_location intersected_region.location, to, from
-      intersected_region
-    end
-
-    def location_in_screenshot(location, coordinates_type)
-      Applitools::ArgumentGuard.not_nil location, 'location'
-      Applitools::ArgumentGuard.not_nil coordinates_type, 'coordinates_type'
-      location = convert_location(location, coordinates_type, CONTEXT_RELATIVE)
-
-      unless bounds.contains? location.left, location.top
-        raise Applitools::OutOfBoundsException.new "Location #{location} is not available in screenshot!"
-      end
-
-      convert_location location, CONTEXT_RELATIVE, SCREENSHOT_AS_IS
-    end
-
-    def sub_screenshot(region, coordinates_type, throw_if_clipped = false, force_nil_if_clipped = false)
-      Applitools::ArgumentGuard.not_nil region, 'region'
-      Applitools::ArgumentGuard.not_nil coordinates_type, 'coordinates_type'
-
-      sub_screen_region = intersected_region region, coordinates_type, SCREENSHOT_AS_IS
-
-      if sub_screen_region.empty? || (throw_if_clipped && !region.size_equals?(sub_screen_region))
-        return nil if force_nil_if_clipped
-        Applitools::OutOfBoundsException.new "Region #{sub_screen_region} (#{coordinates_type}) is out of " \
-          " screenshot bounds #{bounds}"
-      end
-
-      sub_screenshot_image = Applitools::Screenshot.from_any_image(
-        image.crop(
-          sub_screen_region.left, sub_screen_region.top, sub_screen_region.width, sub_screen_region.height
-        ).to_datastream.to_blob
-      )
-
-      relative_sub_screenshot_region = convert_region_location(sub_screen_region, SCREENSHOT_AS_IS, CONTEXT_RELATIVE)
-
-      Applitools::Images::EyesImagesScreenshot.new sub_screenshot_image,
-        location: relative_sub_screenshot_region.location
-    end
-
-    private
-
-    def bounds
-      @bounds ||= Applitools::Region.new(0, 0, image.width, image.height)
-    end
-  end
-end