eyes_selenium 2.15.0 → 2.16.0

data/lib/eyes_selenium/eyes/test_results.rb

@@ -1,32 +0,0 @@
-class Applitools::TestResults
-  attr_accessor :is_new, :url
-  attr_reader :steps, :matches, :mismatches, :missing, :exact_matches, :strict_matches,
-              :content_matches, :layout_matches, :none_matches, :is_passed
-  def initialize(steps=0, matches=0, mismatches=0, missing=0,
-                 exact_matches=0, strict_matches=0, content_matches=0, 
-                 layout_matches=0, none_matches=0)
-    @steps = steps
-    @matches = matches
-    @mismatches =  mismatches
-    @missing =  missing
-    @exact_matches =  exact_matches
-    @strict_matches = strict_matches
-    @content_matches =  content_matches
-    @layout_matches =  layout_matches
-    @none_matches =  none_matches
-    @is_new = nil
-    @url = nil
-  end
-
-  def is_passed
-    !is_new && mismatches == 0 && missing ==0
-  end
-
-  def to_s
-    is_new_str = ""
-    unless is_new.nil?
-      is_new_str = is_new ? "New test" : "Existing test"
-    end
-    "#{is_new_str} [ steps: #{steps}, matches: #{matches}, mismatches: #{mismatches}, missing: #{missing} ], URL: #{url}"
-  end
-end

data/lib/eyes_selenium/eyes/text_trigger.rb

@@ -1,19 +0,0 @@
-class Applitools::TextTrigger
-  
-  attr_reader :text, :control
-
-  def initialize(text, control)
-    @text = text
-    @control = control
-  end
-
-  def to_hash
-    {
-      triggetType: 'Text', text: text, control: control.to_hash
-    }
-  end
-
-  def to_s
-    "Text [#{@control}] #{@text}"
-  end
-end

data/lib/eyes_selenium/eyes/viewport_size.rb

@@ -1,105 +0,0 @@
-class Applitools::ViewportSize
-
-  JS_GET_VIEWPORT_HEIGHT =
-      'var height = undefined;' +
-      '  if (window.innerHeight) {height = window.innerHeight;}' +
-      '  else if (document.documentElement ' +
-        '&& document.documentElement.clientHeight) ' +
-          '{height = document.documentElement.clientHeight;}' +
-      '  else { var b = document.getElementsByTagName("body")[0]; ' +
-                'if (b.clientHeight) {height = b.clientHeight;}' +
-          '};' +
-      'return height;'
-
-  JS_GET_VIEWPORT_WIDTH  =
-      'var width = undefined;' +
-      ' if (window.innerWidth) {width = window.innerWidth;}' +
-      ' else if (document.documentElement ' +
-          '&& document.documentElement.clientWidth) ' +
-            '{width = document.documentElement.clientWidth;}' +
-      ' else { var b = document.getElementsByTagName("body")[0]; ' +
-              'if (b.clientWidth) {' +
-                'width = b.clientWidth;}' +
-              '};' +
-            'return width;'
-
-  attr_reader :driver
-  attr_accessor :dimension
-  def initialize(driver, dimension=nil)
-    @driver = driver
-    @dimension = dimension
-  end
-
-  def extract_viewport_width
-    driver.execute_script(JS_GET_VIEWPORT_WIDTH)
-  end
-
-  def extract_viewport_height
-    driver.execute_script(JS_GET_VIEWPORT_HEIGHT)
-  end
-
-  def extract_viewport_from_browser!
-    self.dimension = extract_viewport_from_browser
-  end
-
-  def extract_viewport_from_browser
-    width, height = nil, nil
-    begin
-      width  = extract_viewport_width
-      height = extract_viewport_height
-    rescue => e
-      EyesLogger.info "#{__method__}(): Failed to extract viewport size using Javascript: (#{e.message})"
-    end
-    if width.nil? || height.nil?
-      EyesLogger.info "#{__method__}(): Using window size as viewport size."
-      width, height = *browser_size.values
-      width, height = width.ceil, height.ceil
-      if driver.landscape_orientation? && height > width
-        width, height = height, width
-      end
-    end
-    Applitools::Dimension.new(width,height)
-  end
-  alias_method :viewport_size, :extract_viewport_from_browser
-
-  def set
-    if dimension.is_a?(Hash) && dimension.has_key?(:width) && dimension.has_key?(:height)
-      # If dimension is hash of width/height, we convert it to a struct with width/height properties.
-      self.dimension = Struct.new(:width, :height).new(dimension[:width], dimension[:height])
-    elsif !dimension.respond_to?(:width) || !dimension.respond_to?(:height)
-      raise ArgumentError, "expected #{dimension.inspect}:#{dimension.class}" +
-                           ' to respond to #width and #height, or be a hash with these keys.'
-    end
-    self.browser_size = dimension
-    verify_size(:browser_size)
-    cur_viewport_size = extract_viewport_from_browser
-    self.browser_size = Applitools::Dimension.new(
-                          (2 * browser_size.width) - cur_viewport_size.width,
-                          (2 * browser_size.height) - cur_viewport_size.height
-                        )
-    verify_size(:viewport_size)
-  end
-
-  def verify_size(to_verify, sleep_time=1, retries=3)
-    cur_size = nil
-    retries.times do
-      sleep(sleep_time)
-      cur_size = send(to_verify)
-      return if cur_size.values == dimension.values
-    end
-    EyesLogger.info(err_msg = "Failed setting #{to_verify} to #{dimension.values} (current size: #{cur_size.values})")
-    raise Applitools::TestFailedError.new(err_msg)
-  end
-
-  def browser_size
-    driver.manage.window.size
-  end
-
-  def browser_size=(other)
-    self.driver.manage.window.size = other
-  end
-
-  def to_hash
-    Hash[dimension.each_pair.to_a]
-  end
-end

data/lib/eyes_selenium/eyes_logger.rb

@@ -1,47 +0,0 @@
-require 'logger'
-
-module EyesLogger
-
-  class NullLogger
-    attr_accessor :level
-
-    def info(msg)
-      # do nothing
-    end
-    def debug(msg)
-      #do nothing
-    end 
-  end
-
-  NULL_LOGGER = NullLogger.new
-
-  @@log_handler = NULL_LOGGER
-
-  def self.log_handler=(log_handler)
-    if !log_handler.respond_to?(:info) || !log_handler.respond_to?(:debug)
-      raise Applitools::EyesError.new('log handler must respond to "info" and "debug"!')
-    end
-    @@log_handler = log_handler
-  end
-
-  def self.info(msg)
-    @@log_handler.info(msg)
-  end
-
-  def self.debug(msg)
-    @@log_handler.debug(msg)
-  end
-
-  def self.open
-    if @@log_handler.respond_to?(:open)
-      @@log_handler.open
-    end
-  end
-
-  def self.close
-    if @@log_handler.respond_to?(:close)
-      @@log_handler.close
-    end
-  end
-
-end

data/lib/eyes_selenium/utils.rb

@@ -1,6 +0,0 @@
-module Applitools
-  module Utils
-    require 'eyes_selenium/utils/image_delta_compressor'
-    require 'eyes_selenium/utils/image_utils'
-  end
-end

data/lib/eyes_selenium/utils/image_delta_compressor.rb

@@ -1,149 +0,0 @@
-=begin
-Applitools SDK class.
-
-Provides image compression based on image sequences and deflate.
-=end
-require 'oily_png'
-
-class Applitools::Utils::ImageDeltaCompressor
-
-  # 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 self.compress_by_raw_blocks(target, target_encoded, source, block_size = 10)
-    # 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) == 0 ? 0 : 1)
-    block_rows_count = (target.height / block_size) + ((target.height % block_size) == 0 ? 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)
-
-          if !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
-    return compression_result
-  end
-
-
-  ### PRIVATE
-  private
-
-  @@PREAMBLE = 'applitools'
-  @@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 self.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 self.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]
-        if source_byte != target_byte
-          identical = false
-        end
-        channel_bytes << target_byte
-        offset += pixel_length
-      end
-    end
-    # Returning the compare-and-copy result
-    CompareAndCopyBlockChannelDataResult.new(identical, channel_bytes)
-  end
-end

data/lib/eyes_selenium/utils/image_utils.rb

@@ -1,76 +0,0 @@
-=begin
-Applitools SDK class.
-
-Provides images manipulation functionality.
-=end
-require 'oily_png'
-require 'base64'
-
-module Applitools::Utils::ImageUtils
-
-  # 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 self.png_image_from_bytes(png_bytes)
-    EyesLogger.debug "#{__method__}()"
-    image = ChunkyPNG::Image.from_blob(png_bytes)
-    EyesLogger.debug 'Done!'
-    return image
-  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 self.png_image_from_base64(png_bytes64)
-    EyesLogger.debug "#{__method__}()"
-    png_bytes = Base64.decode64(png_bytes64)
-    EyesLogger.debug 'Done!'
-    return png_image_from_bytes(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 self.bytes_from_png_image(image)
-    EyesLogger.debug "#{__method__}()"
-    png_bytes = image.to_blob
-    EyesLogger.debug 'Done!'
-    return png_bytes
-  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 self.base64_from_png_image(image)
-    EyesLogger.debug "#{__method__}()"
-    png_bytes = bytes_from_png_image(image)
-    EyesLogger.debug 'Encoding as base64...'
-    image64 = Base64.encode64(png_bytes)
-    EyesLogger.debug 'Done!'
-    return image64
-  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 self.quadrant_rotate!(image, num_quadrants)
-    rotate_method = num_quadrants > 0 ? image.method('rotate_right!'.to_sym) : image.method('rotate_left!'.to_sym)
-    (0..(num_quadrants.abs-1)).each { rotate_method.call }
-    return image
-  end
-end

data/lib/eyes_selenium/version.rb

@@ -1,3 +0,0 @@
-module Applitools
-  VERSION = '2.15.0'
-end