eyes_images 4.0.0.alpha → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: d57304fb9f70a31cdd54d4d858518da1bb743242300cb7f6b44fca409e0ee474
-  data.tar.gz: 0a8912459d6a810501f61c7d33dfa5fb318832ab35d3ef962640b075950e4a72
+SHA1:
+  metadata.gz: 71125b4f052c21e79a5b50b6e553c079c55ee792
+  data.tar.gz: 3fc0aa90e059f26fd13f82f8cd01f4399bc93665
 SHA512:
-  metadata.gz: 026b9ed41e630373d5ce26a269f77a075789e28c5aef3842ccf4b6b07ec60900e8996b4f1fa7be2085be74fc1207f9476039daf5dbd893421b4743277ed55033
-  data.tar.gz: b967d91e24a201491432165860f8c198a0f67ff43fc13b4a941754433c80a175a04c4233710885549360a7dc8964d4729c784395d85b390d29080a5fe6b05b94
+  metadata.gz: d89e69a8b1a86ecd33fc51e35dddc8a8cb70d95b7100ad821e4c804e954148ba461f0aa88feb9913e07c4520f27c47f9d69b300df5fabb7367050660ec8f20fd
+  data.tar.gz: f1925352ff32e967a17d8c8d0fd2be3b0e3db40c95bd6fe84c7e774c4a3c356ebf44cf95c51813735f79a037c4296a9cb642c88136dc45ea36d1d4e9bbff03a1

data/lib/applitools/images/eyes.rb

@@ -42,8 +42,7 @@ 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]
-      # options = Applitools::Utils.extract_options!(args)
-      universal_open(options)
+      open_base options
     end
 
     # Opens eyes using passed options, yields the block and then closes eyes session.
@@ -94,9 +93,6 @@ 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
@@ -168,8 +164,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(options).ignore_mismatch(options[:ignore_mismatch])
+      image = get_image_from_options(options)
+      target = Applitools::Images::Target.any(image).ignore_mismatch(options[:ignore_mismatch])
       check(options[:tag], target)
     end
 
@@ -189,10 +185,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: '', ignore_mismatch: false }.merge options
+      options = { tag: nil, 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(options).ignore_mismatch(options[:ignore_mismatch])
+      image = get_image_from_options options
+      target = Applitools::Images::Target.any(image).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)
@@ -236,22 +232,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]
-    #             # 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
+    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
   end
 end

data/lib/applitools/images/eyes_images_screenshot.rb

@@ -0,0 +1,96 @@
+# 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

data/lib/applitools/images/target.rb

@@ -6,20 +6,19 @@ 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(path)
+        new Applitools::Screenshot.from_image(ChunkyPNG::Image.from_file(path))
       end
 
       def blob(blob_image)
         Applitools::ArgumentGuard.not_nil blob_image, 'blob_image'
         Applitools::ArgumentGuard.is_a? blob_image, 'blob_image', String
-        new(blob_image)
+        new Applitools::Screenshot.from_datastream(blob_image)
       end
 
       def image(image)
         Applitools::ArgumentGuard.not_nil image, 'image'
-        # Applitools::ArgumentGuard.is_a? image, 'image', ChunkyPNG::Image
-        new(image)
+        Applitools::ArgumentGuard.is_a? image, 'image', ChunkyPNG::Image
+        new Applitools::Screenshot.from_image(image)
       end
 
       def screenshot(screenshot)
@@ -29,36 +28,28 @@ module Applitools::Images
       end
 
       def any(screenshot)
-        new(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
       end
     end
 
     attr_accessor :image, :options, :ignored_regions, :region_to_check, :floating_regions, :accessibility_regions
 
-    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)
+    def initialize(image)
       Applitools::ArgumentGuard.not_nil(image, 'image')
-      Applitools::ArgumentGuard.is_a? image, 'image', String
+      Applitools::ArgumentGuard.is_a? image, 'image', Applitools::Screenshot
       self.image = image
       self.ignored_regions = []
       self.floating_regions = []
@@ -69,67 +60,47 @@ module Applitools::Images
     end
 
     def ignore(*args)
-      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
-        {}
-      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
+      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)
       else
-        {}
+        self.ignored_regions = []
       end
+      self
     end
 
     def floating(*args)
-      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
+      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
       self
     end
 
     def region(region = nil)
       if region
         Applitools::ArgumentGuard.is_a? region, 'region', Applitools::Region
-        self.region_to_check = region.to_hash
+        self.region_to_check = region
       else
         self.region_to_check = nil
       end
@@ -148,60 +119,5 @@ 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,7 +1,6 @@
 # frozen_string_literal: false
 
 module Applitools
-  VERSION = '4.5.0.beta'.freeze
-  IMAGES_VERSION = '4.0.0.alpha'.freeze
-  UNIVERSAL_VERSION = '3.0.2'.freeze
+  VERSION = '4.0.0'.freeze
+  UNIVERSAL_VERSION = '1.0.6'.freeze
 end

metadata

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