eyes_core 5.0.0 → 6.0.0

data/lib/applitools/appium/target.rb

@@ -1,240 +0,0 @@
-# frozen_string_literal: true
-
-module Applitools
-  module Appium
-    class Target < Applitools::Selenium::Target
-
-      def ignore(*args)
-        if args.empty?
-          reset_ignore
-        else
-          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') && !is_a?(Applitools::Appium::Target)
-          ignored_regions << value
-        end
-        self
-      end
-
-      def region(*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') && !is_a?(Applitools::Appium::Target)
-        self.region_to_check = value
-        self.coordinate_type = Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative]
-        options[:timeout] = nil
-        reset_ignore
-        reset_floating
-        self
-      end
-
-      def webview(value = true)
-        options[:webview] = value.is_a?(String) ? value : !!value
-        # options[:stitch_content] = false if options[:stitch_content].nil?
-        self
-      end
-
-    # class Target
-    #   include Applitools::FluentInterface
-    #   attr_accessor :region_to_check, :options, :ignored_regions, :floating_regions, :layout_regions, :content_regions, :strict_regions, :accessibility_regions
-    #
-    #   class << self
-    #     def window
-    #       new
-    #     end
-    #
-    #     def region(*args)
-    #       new.region(*args)
-    #     end
-    #   end
-    #
-    #   def initialize
-    #     self.region_to_check = proc { Applitools::Region::EMPTY }
-    #     self.ignored_regions = []
-    #     self.floating_regions = []
-    #     self.layout_regions = []
-    #     self.content_regions = []
-    #     self.strict_regions = []
-    #     self.accessibility_regions = []
-    #     self.options = {}
-    #   end
-    #
-    #   def region(*args)
-    #     self.region_to_check = case args.first
-    #                            when ::Selenium::WebDriver::Element
-    #                              proc { args.first }
-    #                            else
-    #                              proc do |driver|
-    #                                driver.find_element(*args)
-    #                              end
-    #                            end
-    #     self
-    #   end
-    #
-    #   def ignore(*args)
-    #     requested_padding = if args.last.is_a? Applitools::PaddingBounds
-    #                           args.pop
-    #                         else
-    #                           Applitools::PaddingBounds::ZERO_PADDING
-    #                         end
-    #     ignored_regions <<  case (first_argument = args.first)
-    #                         when ::Selenium::WebDriver::Element
-    #                           proc do
-    #                             Applitools::Region
-    #                               .from_location_size(first_argument.location, first_argument.size)
-    #                               .padding(requested_padding)
-    #                           end
-    #                         when Applitools::Region
-    #                           result = first_argument.padding(requested_padding)
-    #                           if Applitools::Appium::Utils.ios?(Applitools::Appium::Driver::AppiumLib)
-    #                             def result.converted?
-    #                               true
-    #                             end
-    #                           end
-    #                           result
-    #                         else
-    #                           proc do |driver|
-    #                             element = driver.find_element(*args)
-    #                             Applitools::Region
-    #                               .from_location_size(element.location, element.size)
-    #                               .padding(requested_padding)
-    #                           end
-    #                         end
-    #     self
-    #   end
-    #
-    #   def floating(*args)
-    #     value = case args.first
-    #             when Applitools::FloatingRegion
-    #               args.first
-    #             when Applitools::Region
-    #               result = Applitools::FloatingRegion.any(*args)
-    #               if Applitools::Appium::Utils.ios?(Applitools::Appium::Driver::AppiumLib)
-    #                 def result.converted?
-    #                   true
-    #                 end
-    #               end
-    #               result
-    #             when ::Selenium::WebDriver::Element
-    #               args_dup = args.dup
-    #               Applitools::FloatingRegion.any(*args_dup)
-    #             else
-    #               proc do |driver|
-    #                 args_dup = args.dup
-    #                 region = driver.find_element(args_dup.shift, args_dup.shift)
-    #                 Applitools::FloatingRegion.any(
-    #                     region, *args_dup
-    #                 )
-    #               end
-    #             end
-    #     floating_regions << value
-    #     self
-    #   end
-    #
-    #   def layout
-    #     return match_level(Applitools::MatchLevel::LAYOUT) if args.empty?
-    #     region = process_region(*args)
-    #     layout_regions << region
-    #   self
-    #
-    #   end
-    #
-    #   def content(*args)
-    #     return match_level(Applitools::MatchLevel::CONTENT) if args.empty?
-    #     region = process_region(*args)
-    #     content_regions << region
-    #     self
-    #   end
-    #
-    #   def strict(*args)
-    #     return match_level(Applitools::MatchLevel::STRICT) if args.empty?
-    #     region = process_region(*args)
-    #     strict_regions << region
-    #     self
-    #   end
-    #
-    #   def exact(*args)
-    #     match_level(Applitools::MatchLevel::EXACT, *args)
-    #   end
-    #
-    #   def accessibility(*args)
-    #     options = Applitools::Utils.extract_options! args
-    #     unless options[:type]
-    #       raise Applitools::EyesError,
-    #             'You should call Target.accessibility(region, type: type). The region_type option is required'
-    #     end
-    #     unless Applitools::AccessibilityRegionType.enum_values.include?(options[:type])
-    #       raise Applitools::EyesIllegalArgument,
-    #             "The region type should be one of [#{Applitools::AccessibilityRegionType.enum_values.join(', ')}]"
-    #     end
-    #
-    #     accessibility_regions << case args.first
-    #                              when ::Selenium::WebDriver::Element
-    #                                element = args.first
-    #                                Applitools::AccessibilityRegion.new(
-    #                                  element,
-    #                                  options[:type]
-    #                                )
-    #                              when Applitools::Region
-    #                                result = Applitools::AccessibilityRegion.new(
-    #                                    args.first, options[:type]
-    #                                )
-    #                                if Applitools::Appium::Utils.ios?(Applitools::Appium::Driver::AppiumLib)
-    #                                  def result.converted?
-    #                                    true
-    #                                  end
-    #                                end
-    #                                result
-    #                              when String
-    #                                proc do |driver|
-    #                                  element = driver.find_element(name_or_id: args.first)
-    #                                  Applitools::AccessibilityRegion.new(
-    #                                    element,
-    #                                    options[:type]
-    #                                  )
-    #                                end
-    #                              else
-    #                                proc do |driver|
-    #                                  elements = driver.find_elements(*args)
-    #                                  elements.map do |e|
-    #                                    Applitools::AccessibilityRegion.new(
-    #                                      e,
-    #                                      options[:type]
-    #                                    )
-    #                                  end
-    #                                end
-    #                              end
-    #     self
-    #   end
-    #
-    #   def finalize
-    #     self
-    #   end
-    #
-    #   private
-    #
-    #   def process_region(*args)
-    #     r = args.first
-    #     case r
-    #     when ::Selenium::WebDriver::Element
-    #       proc do |driver|
-    #         Applitools::Region.from_location_size(r.location, r.size)
-    #       end
-    #     when Applitools::Region
-    #       if Applitools::Appium::Utils.ios?(Applitools::Appium::Driver::AppiumLib)
-    #         def r.converted?
-    #           true
-    #         end
-    #       end
-    #       r
-    #     else
-    #       proc do |driver|
-    #         element = driver.find_element(*args)
-    #         Applitools::Region.from_location_size(element.location, element.size)
-    #       end
-    #     end
-    #   end
-    #
-    end
-  end
-end

data/lib/applitools/appium/utils.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: false
-
-module Applitools::Appium
-  module Utils
-    include Applitools::Utils::EyesSeleniumUtils
-    extend self
-
-    # true if test is running on mobile device
-    def mobile_device?(driver)
-      defined?(Appium::Driver) &&
-          defined?(Applitools::Appium::Driver::AppiumLib) &&
-          Applitools::Appium::Driver::AppiumLib
-    end
-
-    # true if test is running on Android device
-    def android?(driver)
-      driver.respond_to?(:device_is_android?) && driver.device_is_android?
-    end
-
-    # true if test is running on iOS device
-    def ios?(driver)
-      driver.respond_to?(:device_is_ios?) && driver.device_is_ios?
-    end
-
-    # @param [Applitools::Selenium::Driver] driver
-    def platform_version(driver)
-      driver.respond_to?(:platform_version) && driver.platform_version
-    end
-
-    # @param [Applitools::Selenium::Driver] executor
-    def device_pixel_ratio(executor)
-      session_info = session_capabilities(executor)
-      return session_info['pixelRatio'].to_f if session_info['pixelRatio']
-      1
-    end
-
-    def status_bar_height(executor)
-      session_info = session_capabilities(executor)
-      return session_info['statBarHeight'].to_i if session_info['statBarHeight']
-      0
-    end
-
-    def viewport_rect(executor)
-      session_info = session_capabilities(executor)
-      return session_info['viewportRect'] if session_info['viewportRect']
-      {
-        'left' => 0,
-        'top' => 0,
-        'width' => 0,
-        'height' => 0
-      }
-    end
-
-    def session_capabilities(executor)
-       executor.session_capabilities if executor.respond_to? :session_capabilities
-    end
-
-    def current_scroll_position(driver)
-      super
-    rescue
-      Applitools::Location::TOP_LEFT
-    end
-  end
-end

data/lib/applitools/calabash/calabash_element.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Applitools
-  module Calabash
-    class CalabashElement
-      extend Forwardable
-      attr_reader :original_element, :element_query
-      def_delegators :@original_element, :[], :keys, :values
-
-      def initialize(element, element_query)
-        raise Applitools::EyesIllegalArgument, "Invalid element passed! (#{element})" unless valid_element?(element)
-        @original_element = element
-        @element_query = element_query
-      end
-
-      def left
-        self['rect']['x']
-      end
-
-      alias x left
-
-      def top
-        self['rect']['y']
-      end
-
-      alias y top
-
-      def width
-        self['rect']['width']
-      end
-
-      def height
-        self['rect']['height']
-      end
-
-      def location
-        Applitools::Location.from_struct(self)
-      end
-
-      def size
-        Applitools::RectangleSize.from_struct(self)
-      end
-
-      def region
-        Applitools::Region.from_location_size(location, size)
-      end
-
-      def to_s
-        @original_element
-      end
-
-      private
-
-      def valid_element?(element)
-        result = true
-        result &&= element.is_a?(Hash)
-        result &&= element.key?('rect')
-        result &&= (rect = element['rect']).is_a?(Hash)
-        result &&= (%w(height width y x center_x center_y) - rect.keys).empty?
-        result
-      end
-    end
-  end
-end

data/lib/applitools/calabash/calabash_screenshot_provider.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Applitools
-  module Calabash
-    class CalabashScreenshotProvider
-      WAIT_BEFORE_SCREENSHOT = 1
-      attr_reader :density, :context, :debug_screenshot_provider
-
-      def initialize(_options = {})
-        @density = 1
-      end
-
-      def with_density(value)
-        @density = value
-        self
-      end
-
-      def using_context(value)
-        @context = value
-        self
-      end
-
-      def with_debug_screenshot_provider(value)
-        Applitools::ArgumentGuard.is_a?(
-          value,
-          'debug_screenshot_provider',
-          Applitools::DebugScreenshotProvider
-        )
-        @debug_screenshot_provider = value
-        self
-      end
-
-      private
-
-      def save_debug_screenshot(screenshot, suffix)
-        suffix = suffix.join('_') if suffix.respond_to? :join
-        debug_screenshot_provider.save(screenshot, suffix || '') if debug_screenshot_provider
-      end
-    end
-
-    class AndroidScreenshotProvider < CalabashScreenshotProvider
-      include Singleton
-
-      def capture_screenshot(options = {})
-        sleep WAIT_BEFORE_SCREENSHOT
-        result = nil
-        # Applitools::Calabash::Utils.using_screenshot(context) do |screenshot_path|
-        #   screenshot = ::ChunkyPNG::Image.from_file(screenshot_path)
-        #   save_debug_screenshot(screenshot, ['original', options[:debug_suffix]])
-        #   viewport_size = Applitools::Calabash::EyesSettings.instance.viewport_size
-        #   screenshot.crop!(0, 0, viewport_size[:width], viewport_size[:height])
-        #   save_debug_screenshot(screenshot, ['cropped', options[:debug_suffix]])
-        #   result = Applitools::Calabash::EyesCalabashAndroidScreenshot.new(
-        #     Applitools::Screenshot.from_image(
-        #       screenshot
-        #     ),
-        #     density: density
-        #   )
-        # end
-        result
-      end
-    end
-
-    class IosScreenshotProvider < CalabashScreenshotProvider
-      include Singleton
-      def capture_screenshot(options = {})
-        sleep WAIT_BEFORE_SCREENSHOT
-        result = nil
-        # Applitools::Calabash::Utils.using_screenshot(context) do |screenshot_path|
-        #   screenshot = ::ChunkyPNG::Image.from_file(screenshot_path)
-        #   save_debug_screenshot(screenshot, options[:debug_suffix])
-        #   result = Applitools::Calabash::EyesCalabashIosScreenshot.new(
-        #     Applitools::Screenshot.from_image(
-        #       screenshot
-        #     ),
-        #     scale_factor: density
-        #   )
-        # end
-        result
-      end
-    end
-  end
-end

data/lib/applitools/calabash/environment_detector.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Applitools
-  module Calabash
-    module EnvironmentDetector
-      extend self
-
-      def android?
-        return true if defined?(::Calabash::Android) == 'constant'
-        false
-      end
-
-      def ios?
-        return true if defined?(::Calabash::Cucumber) == 'constant'
-        false
-      end
-
-      def current_environment
-        return :android if android?
-        return :ios if ios?
-        raise Applitools::EyesError, 'No calabash environment found!'
-      end
-    end
-  end
-end

data/lib/applitools/calabash/eyes.rb

@@ -1,194 +0,0 @@
-# frozen_string_literal: false
-
-module Applitools
-  module Calabash
-    class Eyes < Applitools::EyesBase
-      attr_accessor :device_pixel_ratio, :full_page_capture_algorithm, :base_agent_id, :title,
-        :debug_screenshots, :debug_screenshot_provider, :tag_for_debug
-      attr_reader :context
-
-      def initialize(server_url = Applitools::Connectivity::ServerConnector::DEFAULT_SERVER_URL)
-        super
-        self.runner = Applitools::ClassicRunner.new
-        self.base_agent_id = "eyes.calabash.ruby/#{Applitools::VERSION}".freeze
-        self.debug_screenshots = false
-        self.debug_screenshot_provider = Applitools::DebugScreenshotProvider.new
-                                                                            .tag_access { tag_for_debug }
-                                                                            .debug_flag_access { debug_screenshots }
-      end
-
-      def open(options = {})
-        Applitools::ArgumentGuard.hash options, 'open(options)', [:app_name, :test_name]
-        open_base options
-      end
-
-      def check(*args)
-        args.compact!
-        case (first_arg = args.shift)
-        when String
-          name = first_arg
-          target = args.shift
-        when Applitools::Selenium::Target
-          target = first_arg
-        when Hash
-          target = first_arg[:target]
-          name = first_arg[:name] || first_arg[:tag]
-        end
-
-        self.tag_for_debug = get_tag_for_debug(name)
-        check_it(name, target, Applitools::MatchWindowData.new(default_match_settings))
-      end
-
-      def inferred_environment
-        return @inferred_environment unless @inferred_environment.nil?
-        return unless device_pixel_ratio
-        "device pixel ratio: #{device_pixel_ratio}"
-      end
-
-      def add_context(value)
-        @context = value
-      end
-
-      def remove_context
-        @context = nil
-      end
-
-      def capture_screenshot
-        return screenshot_provider.capture_screenshot(debug_suffix: tag_for_debug) unless full_page_capture_algorithm
-        full_page_capture_algorithm.get_stitched_region
-      end
-
-      def screenshot_provider
-        env = Applitools::Calabash::EnvironmentDetector.current_environment
-        case env
-        when :android
-          Applitools::Calabash::AndroidScreenshotProvider.instance.with_density(device_pixel_ratio)
-                                                         .using_context(context)
-                                                         .with_debug_screenshot_provider(debug_screenshot_provider)
-        when :ios
-          Applitools::Calabash::IosScreenshotProvider.instance.with_density(device_pixel_ratio)
-                                                     .using_context(context)
-                                                     .with_debug_screenshot_provider(debug_screenshot_provider)
-        end
-      end
-
-      def check_it(name, target, match_window_data)
-        Applitools::ArgumentGuard.not_nil(name, 'name')
-
-        logger.info 'Full element requested' if target.options[:stitch_content]
-
-        self.full_page_capture_algorithm = target.options[:stitch_content] &&
-          get_full_page_capture_algorithm(target.region_to_check)
-
-        region_provider = if full_page_capture_algorithm
-                            entire_screenshot_region
-                          else
-                            get_region_provider(target)
-                          end
-
-        match_window_data.tag = name
-        match_window_data.read_target(target, nil)
-
-        self.viewport_size = Applitools::Calabash::EyesSettings.instance.viewport_size if viewport_size.nil?
-
-        if match_window_data.is_a? Applitools::MatchSingleCheckData
-          return check_single_base(
-            region_provider,
-            target.options[:timeout] || Applitools::EyesBase::USE_DEFAULT_TIMEOUT,
-            match_window_data
-          )
-        end
-
-        check_window_base(
-          region_provider,
-          target.options[:timeout] || Applitools::EyesBase::USE_DEFAULT_TIMEOUT,
-          match_window_data
-        )
-      end
-
-      def get_region_provider(target)
-        if (region_to_check = target.region_to_check).nil?
-          entire_screenshot_region
-        else
-          region_for_element(region_to_check)
-        end
-      end
-
-      def get_app_output_with_screenshot(*args)
-        result = super(*args, &:scale_it!)
-        self.screenshot_url = nil
-        result
-      end
-
-      def entire_screenshot_region
-        Object.new.tap do |prov|
-          prov.instance_eval do
-            define_singleton_method :region do
-              Applitools::Region::EMPTY
-            end
-
-            define_singleton_method :coordinate_type do
-              nil
-            end
-          end
-        end
-      end
-
-      def region_for_element(region_to_check)
-        Object.new.tap do |prov|
-          prov.instance_eval do
-            define_singleton_method :region do
-              case region_to_check
-              when Applitools::Calabash::CalabashElement
-                region_to_check.region
-              when Applitools::Region
-                region_to_check
-              else
-                raise Applitools::EyesError, "Incompatible region type: #{region_to_check.class}"
-              end
-              # region_to_check.respond_to?(:region) ? region_to_check.region : region_to_check
-            end
-            define_singleton_method :coordinate_type do
-              Applitools::Calabash::EyesCalabashScreenshot::DRIVER
-            end
-          end
-        end
-      end
-
-      def vp_size
-        viewport_size
-      end
-
-      def vp_size=(value, skip_check_if_open = false)
-        unless skip_check_if_open || open?
-          raise Applitools::EyesNotOpenException.new 'set_viewport_size: Eyes not open!'
-        end
-        Applitools::ArgumentGuard.not_nil 'value', value
-        @viewport_size = Applitools::RectangleSize.for value
-      end
-
-      alias get_viewport_size vp_size
-      alias set_viewport_size vp_size=
-
-      def get_full_page_capture_algorithm(element)
-        logger.info "Trying to get full page capture algorithm for element #{element}..."
-        environment = Applitools::Calabash::EnvironmentDetector.current_environment
-        element_class = Applitools::Calabash::Utils.send("grub_#{environment}_class_name", context, element).first
-        logger.info "Trying to get FullPageCaptureAlgorithm for #{element_class}..."
-        algo = Applitools::Calabash::FullPageCaptureAlgorithm.get_algorithm_class(environment, element_class)
-        if algo
-          logger.info "Using #{algo}"
-          algo = algo.new(screenshot_provider, element, debug_screenshot_provider: debug_screenshot_provider)
-        else
-          logger.info "FullPageCaptureAlgorithm for #{element_class} not found. Continue with :check_region instead"
-        end
-        algo
-      end
-
-      def get_tag_for_debug(name)
-        return "#{app_name} #{test_name}" if name.empty?
-        "#{app_name} #{test_name} - #{name}"
-      end
-    end
-  end
-end