eyes_selenium 2.39.1 → 3.0.6

data/lib/applitools/eyes_logger.rb

@@ -1,38 +0,0 @@
-require 'logger'
-require 'forwardable'
-
-module Applitools::EyesLogger
-  class NullLogger < Logger
-    def initialize(*_args) end
-
-    def add(*_args, &_block) end
-  end
-
-  extend Forwardable
-  extend self
-
-  MANDATORY_METHODS = [:debug, :info, :close].freeze
-  OPTIONAL_METHODS = [:warn, :error, :fatal].freeze
-
-  def_delegators :@log_handler, *MANDATORY_METHODS
-
-  @log_handler = NullLogger.new
-
-  def log_handler=(log_handler)
-    raise Applitools::EyesError.new('log_handler must implement Logger!') unless valid?(log_handler)
-
-    @log_handler = log_handler
-  end
-
-  OPTIONAL_METHODS.each do |method|
-    define_singleton_method(method) do |msg|
-      @log_handler.respond_to?(method) ? @log_handler.send(method, msg) : @log_handler.info(msg)
-    end
-  end
-
-  private
-
-  def valid?(log_handler)
-    MANDATORY_METHODS.all? { |method| log_handler.respond_to?(method) }
-  end
-end

data/lib/applitools/method_tracer.rb

@@ -1,22 +0,0 @@
-module Applitools::MethodTracer
-  def self.included(base)
-    instance_methods = base.instance_methods(false) + base.private_instance_methods(false)
-    class_methods = base.methods(false)
-
-    base.class_eval do
-      def self.trace_method(base, method_name, instance = true)
-        original_method = instance ? instance_method(method_name) : method(method_name)
-
-        send(instance ? :define_method : :define_singleton_method, method_name) do |*args, &block|
-          Applitools::EyesLogger.debug "-> #{base}##{method_name}"
-          return_value = (instance ? original_method.bind(self) : original_method).call(*args, &block)
-          Applitools::EyesLogger.debug "<- #{base}##{method_name}"
-          return_value
-        end
-      end
-
-      instance_methods.each { |method_name| trace_method(base, method_name) }
-      class_methods.each { |method_name| trace_method(base, method_name, false) }
-    end
-  end
-end

data/lib/applitools/poltergeist/applitools_compatible.rb

@@ -1,28 +0,0 @@
-# This module is used for compatibility with Applitools API.
-# Should be extended by Poltergeist driver instance.
-module Applitools::Poltergeist
-  module ApplitoolsCompatible
-    # Implementation of `screenshot_as` method for PhantomJS.
-    # Realisation uses Poltergeist binding to `renderBase64` PhantomJS method.
-    def screenshot_as(fmt)
-      Base64.decode64(browser.render_base64(fmt))
-    end
-
-    # Poltergeist driver does not have `manage` and `window` methods.
-    # In Applitools these methods are used in a chain to get size by `size` method call.
-    %w(manage window).each do |method_name|
-      define_method(method_name) { self }
-    end
-
-    # Method provides opened window size in Applitools format.
-    def size
-      size = window_size(current_window_handle)
-      Applitools::Base::Dimension.new(size[0], size[1])
-    end
-
-    # Method changes opened window size in a way how original Applitools::Selenium::Driver does.
-    def size=(new_size)
-      resize(new_size.width, new_size.height)
-    end
-  end
-end

data/lib/applitools/poltergeist/driver.rb

@@ -1,11 +0,0 @@
-# Applitools::Poltergeist::Driver is a small class implemented
-# for compatibility with Applitools API.
-# It gives required for Applitools methods to Poltergeist driver.
-module Applitools::Poltergeist
-  class Driver < Applitools::Selenium::Driver
-    def initialize(eyes, options)
-      options[:driver].extend Applitools::Poltergeist::ApplitoolsCompatible
-      super(eyes, options)
-    end
-  end
-end

data/lib/applitools/sauce.rb

@@ -1,2 +0,0 @@
-require_relative 'capybara' if defined? Capybara
-Applitools.require_dir 'selenium/sauce'

data/lib/applitools/selenium/match_window_data.rb

@@ -1,28 +0,0 @@
-module Applitools::Selenium
-  class MatchWindowData
-    attr_reader :user_inputs, :app_output, :tag, :ignore_mismatch, :screenshot
-
-    def initialize(app_output, tag, ignore_mismatch, screenshot, user_inputs = [])
-      @user_inputs = user_inputs
-      @app_output = app_output
-      @tag = tag
-      @ignore_mismatch = ignore_mismatch
-      @screenshot = screenshot
-    end
-
-    # IMPORTANT This method returns a hash WITHOUT the screenshot property. This is on purpose! The screenshot should
-    # not be included as part of the json.
-    def to_hash
-      {
-        user_inputs: user_inputs.map(&:to_hash),
-        app_output: Hash[app_output.each_pair.to_a],
-        tag: @tag,
-        ignore_mismatch: @ignore_mismatch
-      }
-    end
-
-    def screenshot
-      @screenshot.to_blob.force_encoding('BINARY')
-    end
-  end
-end

data/lib/applitools/selenium_webdriver.rb

@@ -1,8 +0,0 @@
-if defined? Selenium::WebDriver::Driver
-  Selenium::WebDriver::Driver.class_eval do
-    def driver_for_eyes(eyes)
-      is_mobile_device = capabilities['platformName'] ? true : false
-      Applitools::Selenium::Driver.new(eyes, driver: self, is_mobile_device: is_mobile_device)
-    end
-  end
-end

data/lib/applitools/utils/image_delta_compressor.rb

@@ -1,148 +0,0 @@
-require 'oily_png'
-
-module Applitools::Utils
-  module ImageDeltaCompressor
-    extend self
-
-    BLOCK_SIZE = 10
-
-    # Compresses the target image based on the source image.
-    #
-    # +target+:: +ChunkyPNG::Canvas+ The image to compress based on the source image.
-    # +target_encoded+:: +Array+ The uncompressed image as binary string.
-    # +source+:: +ChunkyPNG::Canvas+ The source image used as a base for compressing the target image.
-    # +block_size+:: +Integer+ The width/height of each block.
-    #
-    # Returns +String+ The binary result (either the compressed image, or the uncompressed image if the compression
-    # is greater in length).
-    def compress_by_raw_blocks(target, target_encoded, source, block_size = BLOCK_SIZE)
-      # If we can't compress for any reason, return the target image as is.
-      if source.nil? || (source.height != target.height) || (source.width != target.width)
-        # Returning a COPY of the target binary string.
-        return String.new(target_encoded)
-      end
-
-      # Preparing the variables we need.
-      target_pixels = target.to_rgb_stream.unpack('C*')
-      source_pixels = source.to_rgb_stream.unpack('C*')
-      image_size = Dimension.new(target.width, target.height)
-      block_columns_count = (target.width / block_size) + ((target.width % block_size).zero? ? 0 : 1)
-      block_rows_count = (target.height / block_size) + ((target.height % block_size).zero? ? 0 : 1)
-
-      # IMPORTANT: The "-Zlib::MAX_WBITS" tells ZLib to create raw deflate compression, without the
-      # "Zlib headers" (this isn't documented in the Zlib page, I found this in some internet forum).
-      compressor = Zlib::Deflate.new(Zlib::BEST_COMPRESSION, -Zlib::MAX_WBITS)
-
-      compression_result = ''
-
-      # Writing the data header.
-      compression_result += PREAMBLE.encode('UTF-8')
-      compression_result += [FORMAT_RAW_BLOCKS].pack('C')
-      compression_result += [0].pack('S>') # Source id, Big Endian
-      compression_result += [block_size].pack('S>') # Big Endian
-
-      # We perform the compression for each channel.
-      3.times do |channel|
-        block_number = 0
-        block_rows_count.times do |block_row|
-          block_columns_count.times do |block_column|
-            actual_channel_index = 2 - channel # Since the image bytes are BGR and the server expects RGB...
-            compare_result = compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, 3,
-              block_size, block_column, block_row, actual_channel_index)
-
-            unless compare_result.identical
-              channel_bytes = compare_result.channel_bytes
-              string_to_compress = [channel].pack('C')
-              string_to_compress += [block_number].pack('L>')
-              string_to_compress += channel_bytes.pack('C*')
-
-              compression_result += compressor.deflate(string_to_compress)
-
-              # If the compressed data so far is greater than the uncompressed representation of the target, just return
-              # the target.
-              if compression_result.length > target_encoded.length
-                compressor.finish
-                compressor.close
-                # Returning a copy of the target bytes.
-                return String.new(target_encoded)
-              end
-            end
-
-            block_number += 1
-          end
-        end
-      end
-
-      # Compress and flush any remaining uncompressed data in the input buffer.
-      compression_result += compressor.finish
-      compressor.close
-
-      # Returning the compressed result as a byte array.
-      compression_result
-    end
-
-    private
-
-    PREAMBLE = 'applitools'.freeze
-    FORMAT_RAW_BLOCKS = 3
-
-    Dimension = Struct.new(:width, :height)
-    CompareAndCopyBlockChannelDataResult = Struct.new(:identical, :channel_bytes)
-
-    # Computes the width and height of the image data contained in the block at the input column and row.
-    # +image_size+:: +Dimension+ The image size in pixels.
-    # +block_size+:: The block size for which we would like to compute the image data width and height.
-    # +block_column+:: The block column index.
-    # +block_row+:: The block row index.
-    # ++
-    # Returns the width and height of the image data contained in the block are returned as a +Dimension+.
-    def get_actual_block_size(image_size, block_size, block_column, block_row)
-      actual_width = [image_size.width - (block_column * block_size), block_size].min
-      actual_height = [image_size.height - (block_row * block_size), block_size].min
-      Dimension.new(actual_width, actual_height)
-    end
-
-    # Compares a block of pixels between the source and target and copies the target's block bytes to the result.
-    # +source_pixels+:: +Array+ of bytes, representing the pixels of the source image.
-    # +target_pixels+:: +Array+ of bytes, representing the pixels of the target image.
-    # +image_size+:: +Dimension+ The size of the source/target image (remember they must be the same size).
-    # +pixel_length+:: +Integer+ The number of bytes composing a pixel
-    # +block_size+:: +Integer+ The width/height of the block (block is a square, theoretically).
-    # +block_column+:: +Integer+ The block column index (when looking at the images as a grid of blocks).
-    # +block_row+:: +Integer+ The block row index (when looking at the images as a grid of blocks).
-    # +channel+:: +Integer+ The index of the channel we're comparing.
-    # ++
-    # Returns +CompareAndCopyBlockChannelDataResult+ object containing a flag saying whether the blocks are identical
-    # and a copy of the target block's bytes.
-    def compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, pixel_length, block_size,
-      block_column, block_row, channel)
-      identical = true
-
-      actual_block_size = get_actual_block_size(image_size, block_size, block_column, block_row)
-
-      # Getting the actual amount of data in the block we wish to copy.
-      actual_block_height = actual_block_size.height
-      actual_block_width = actual_block_size.width
-
-      stride = image_size.width * pixel_length
-
-      # Iterating the block's pixels and comparing the source and target.
-      channel_bytes = []
-      actual_block_height.times do |h|
-        offset = (((block_size * block_row) + h) * stride) + (block_size * block_column * pixel_length) + channel
-        actual_block_width.times do |_w|
-          source_byte = source_pixels[offset]
-          target_byte = target_pixels[offset]
-          identical = false if source_byte != target_byte
-          channel_bytes << target_byte
-          offset += pixel_length
-        end
-      end
-
-      # Returning the compare-and-copy result.
-      CompareAndCopyBlockChannelDataResult.new(identical, channel_bytes)
-    end
-
-    include Applitools::MethodTracer
-  end
-end

data/lib/applitools/utils/image_utils.rb

@@ -1,143 +0,0 @@
-require 'oily_png'
-require 'base64'
-require 'tempfile'
-
-module Applitools::Utils
-  QUADRANTS_COUNT = 4
-
-  module ImageUtils
-    extend self
-
-    # Creates an image object from the PNG bytes.
-    # +png_bytes+:: +String+ A binary string of the PNG bytes of the image.
-    #
-    # Returns:
-    # +ChunkyPNG::Canvas+ An image object.
-    def png_image_from_bytes(png_bytes)
-      ChunkyPNG::Image.from_blob(png_bytes)
-    end
-
-    # Creates an image instance from a base64 representation of its PNG encoding.
-    #
-    # +png_bytes64+:: +String+ The Base64 representation of a PNG image.
-    #
-    # Returns:
-    # +ChunkyPNG::Canvas+ An image object.
-    def png_image_from_base64(png_bytes)
-      png_image_from_bytes(Base64.decode64(png_bytes))
-    end
-
-    # Get the raw PNG bytes of an image.
-    #
-    # +ChunkyPNG::Canvas+ The image object for which to get the PNG bytes.
-    #
-    # Returns:
-    # +String+ The PNG bytes of the image.
-    def bytes_from_png_image(image)
-      image.to_blob(:fast_rgb)
-    end
-
-    # Get the Base64 representation of the raw PNG bytes of an image.
-    #
-    # +ChunkyPNG::Canvas+ The image object for which to get the PNG bytes.
-    #
-    # Returns:
-    # +String+ the Base64 representation of the raw PNG bytes of an image.
-    def base64_from_png_image(image)
-      Base64.encode64(bytes_from_png_image(image))
-    end
-
-    # Rotates a matrix 90 deg clockwise or counter clockwise (depending whether num_quadrants is positive or negative,
-    # respectively).
-    #
-    # +image+:: +ChunkyPNG::Canvas+ The image to rotate.
-    # +num_quadrants+:: +Integer+ The number of rotations to perform. Positive values are used for clockwise rotation
-    #   and negative values are used for counter-clockwise rotation.
-    #
-    def quadrant_rotate!(image, num_quadrants)
-      num_quadrants %= QUADRANTS_COUNT
-
-      case num_quadrants
-      when 0
-        image
-      when 1
-        image.rotate_right!
-      when 2
-        image.rotate_180!
-      when 3
-        image.rotate_left!
-      end
-    end
-
-    def scale!(image, factor)
-      image.resample_nearest_neighbor!(image.width.to_f * factor, image.height.to_f * factor)
-    end
-
-    def stitch_images(size, images_data)
-      stitched_screenshot = ChunkyPNG::Image.new(size.width, size.height, ChunkyPNG::Color::TRANSPARENT).tap do |res|
-        images_data.each do |image_data|
-          # Crop out of bounds images.
-          image = image_data.image
-          position = image_data.position
-
-          new_width = position.left + image.width > size.width ? size.width - position.left : image.width
-          new_height = position.top + image.height > size.height ? size.height - position.top : image.height
-
-          if new_width != image.width || new_height != image.height
-            image = image.crop!(0, 0, new_width, new_height)
-          end
-
-          res.replace!(image.restore, position.left, position.top)
-          GC.start
-        end
-      end
-      result = Applitools::Utils::ImageUtils::Screenshot.new stitched_screenshot.to_blob.dup
-      GC.start
-      result
-    end
-
-    class Screenshot < Delegator
-      extend Forwardable
-      def_delegators :header, :width, :height
-
-      def initialize(image)
-        @datastream = ChunkyPNG::Datastream.from_string image
-      end
-
-      def to_blob
-        @datastream.to_blob
-      end
-
-      def __getobj__
-        restore
-      end
-
-      def header
-        @datastream.header_chunk
-      end
-
-      def __setobj__(obj)
-        @datastream = obj.to_datastream
-        self
-      end
-
-      def method_missing(method, *args, &block)
-        if method =~ /^.+!$/
-          __setobj__ super
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        super
-      end
-
-      def restore
-        ChunkyPNG::Image.from_datastream @datastream
-      end
-    end
-
-    include Applitools::MethodTracer
-  end
-end

data/lib/applitools/utils/utils.rb

@@ -1,49 +0,0 @@
-require 'bigdecimal'
-
-module Applitools::Utils
-  extend self
-
-  def underscore(str)
-    str.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase
-  end
-
-  def uncapitalize(str)
-    str[0, 1].downcase + str[1..-1]
-  end
-
-  def camelcase(str)
-    tokens = str.split('_')
-    uncapitalize(tokens.shift) + tokens.map(&:capitalize).join
-  end
-
-  def wrap(object)
-    if object.nil?
-      []
-    elsif object.respond_to?(:to_ary)
-      object.to_ary || [object]
-    else
-      [object]
-    end
-  end
-
-  def underscore_hash_keys(hash)
-    convert_hash_keys(hash, :underscore)
-  end
-
-  def camelcase_hash_keys(hash)
-    convert_hash_keys(hash, :camelcase)
-  end
-
-  private
-
-  def convert_hash_keys(value, method)
-    case value
-    when Array
-      value.map { |v| convert_hash_keys(v, method) }
-    when Hash
-      Hash[value.map { |k, v| [send(method, k.to_s).to_sym, convert_hash_keys(v, method)] }]
-    else
-      value
-    end
-  end
-end