eyes_core 3.0.4

data/lib/applitools/utils/image_delta_compressor.rb

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

@@ -0,0 +1,146 @@
+require 'base64'
+require 'tempfile'
+
+module Applitools::Utils
+  # @!visibility private
+  QUADRANTS_COUNT = 4
+
+  RESAMPLE_INCREMENTALLY_FRACTION = 2
+
+  module ImageUtils
+    extend self
+
+    # Creates an image object from the PNG bytes.
+    # @param [String] png_bytes A binary string of the PNG bytes of the image.
+    # @return [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.
+    # @param [String] png_bytes The Base64 representation of a PNG image.
+    # @return [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.
+    # @param [ChunkyPNG::Canvas] image The image object for which to get the PNG bytes.
+    # @return [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.
+    # @param [ChunkyPNG::Canvas] image The image object for which to get the PNG bytes.
+    # @return [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).
+    # @param [ChunkyPNG::Canvas] image The image to rotate.
+    # @param [Integer] num_quadrants 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
+
+    # Cuts the image according to passed crop_region. The method mutates an image.
+    # @param [ChunkyPNG::Canvas] image The image to cut
+    # @param [Applitools::Region] crop_region The region which represents cut bounds.
+    #   The area outside crop_region will be removed from the image.
+    def cut!(image, crop_region)
+      image.crop! crop_region.left, crop_region.top, crop_region.width, crop_region.height
+    end
+
+    # Cuts the image according to passed crop_region. The method returns new instance of the image
+    # without changing the source image.
+    # @param [ChunkyPNG::Canvas] image The image to cut
+    # @param [Applitools::Region] crop_region The region which represents cut bounds.
+    #   The area outside crop_region will be removed from the image.
+    def cut(image, crop_region)
+      cut! image.dup, crop_region
+    end
+
+    # Scales image by given +scale factor+ by modifying given image
+    # @param [Applitools::Screenshot] image An image to scale. (The source image will be modified
+    #   by invoking the method)
+    # @param [Float] scale_ratio Scale factor.
+    # @return [Applitools::Screenshot]
+    def scale!(image, scale_ratio)
+      return image if scale_ratio == 1
+      image_ratio = image.width.to_f / image.height.to_f
+      scale_width = (image.width * scale_ratio).ceil
+      scale_height = (scale_width / image_ratio).ceil
+      resize_image!(image, scale_width, scale_height)
+    end
+
+    def scale(image, scale_ratio)
+      scale!(image.dup, scale_ratio)
+    end
+
+    def resize_image!(image, new_width, new_height)
+      Applitools::ArgumentGuard.not_nil(new_width, 'new_width')
+      Applitools::ArgumentGuard.not_nil(new_height, 'new_height')
+      Applitools::ArgumentGuard.not_nil(image, 'image')
+      Applitools::ArgumentGuard.is_a?(image, 'image', Applitools::Screenshot)
+
+      raise Applitools::EyesIllegalArgument.new "Invalid width: #{new_width}" if new_width <= 0
+      raise Applitools::EyesIllegalArgument.new "Invalid height: #{new_height}" if new_height <= 0
+
+      return image if image.width == new_width && image.height == new_height
+
+      if new_width > image.width || new_height > image.height
+        image.resample_bicubic!(new_width, new_height)
+      else
+        scale_image_incrementally!(image, new_width, new_height)
+      end
+    end
+
+    def resize_image(image, new_width, new_height)
+      resize_image!(image.dup, new_width, new_height)
+    end
+
+    def scale_image_incrementally!(image, new_width, new_height)
+      current_width = image.width
+      current_height = image.height
+
+      while current_width != new_width || current_height != new_height
+        prev_current_width = current_width
+        prev_current_height = current_height
+        if current_width > new_width
+          current_width -= (current_width / RESAMPLE_INCREMENTALLY_FRACTION)
+          current_width = new_width if current_width < new_width
+        end
+
+        if current_height > new_height
+          current_height -= (current_height / RESAMPLE_INCREMENTALLY_FRACTION)
+          current_height = new_height if current_height < new_height
+        end
+
+        return image if prev_current_width == current_width && prev_current_height == current_height
+        Applitools::EyesLogger.debug "Incremental dimensions: #{current_width} x #{current_height}"
+        image.resample_bicubic!(current_width, current_height)
+      end
+      image
+    end
+
+    def scale_image_incrementally(image, new_width, new_height)
+      scale_image_incrementally!(image.dup, new_width, new_height)
+    end
+
+    include Applitools::MethodTracer
+  end
+end

data/lib/applitools/utils/utils.rb

@@ -0,0 +1,68 @@
+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
+
+  def boolean_value(value)
+    if value
+      true
+    else
+      false
+    end
+  end
+
+  def symbolize_keys(hash)
+    hash.each_with_object({}) do |(k, v), memo|
+      memo[k.to_sym] = v
+    end
+  end
+
+  def extract_options!(array)
+    return array.pop if array.last.instance_of? Hash
+    {}
+  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

data/lib/applitools/version.rb

@@ -0,0 +1,3 @@
+module Applitools
+  VERSION = '3.0.4'.freeze
+end

data/lib/eyes_core.rb

@@ -0,0 +1,70 @@
+require 'forwardable'
+require 'delegate'
+require 'time'
+
+module Applitools
+  # @!visibility private
+  class << self
+    # @!visibility private
+    def require_dir(dir)
+      Dir[File.join(File.dirname(File.expand_path(__FILE__)), 'applitools', dir, '*.rb')].sort.each do |f|
+        require f
+      end
+    end
+  end
+
+  # @!visibility private
+  class EyesError < StandardError; end
+  # @!visibility private
+  class EyesAbort < EyesError; end
+  # @!visibility private
+  class EyesIllegalArgument < EyesError; end
+  # @!visibility private
+  class EyesNoSuchFrame < EyesError; end
+  # @!visibility private
+  class OutOfBoundsException < EyesError; end
+  # @!visibility private
+  class EyesDriverOperationException < EyesError; end
+  # @!visibility private
+  class EyesNotOpenException < EyesError; end
+  # @!visibility private
+  class EyesCoordinateTypeConversionException < EyesError; end
+
+  # @!visibility private
+  class AbstractMethodCalled < EyesError
+    attr_accessor :method_name, :object
+
+    def initialize(method_name, object)
+      @method = method_name
+      @object = object
+      message = "Abstract method #{method_name} is called for #{object}. "\
+          'You should override it in a descendant class.'
+      super message
+    end
+  end
+
+  # @!visibility private
+  class TestFailedError < StandardError
+    attr_accessor :test_results
+
+    def initialize(message, test_results = nil)
+      super(message)
+
+      @test_results = test_results
+    end
+  end
+
+  # @!visibility private
+  class NewTestError < TestFailedError; end
+end
+
+require_relative 'applitools/method_tracer'
+require_relative 'applitools/extensions'
+require_relative 'applitools/version'
+require_relative 'applitools/chunky_png_patch'
+
+Applitools.require_dir 'core'
+Applitools.require_dir 'connectivity'
+Applitools.require_dir 'utils'
+
+require_relative 'applitools/eyes_logger'

metadata

@@ -0,0 +1,273 @@
+--- !ruby/object:Gem::Specification
+name: eyes_core
+version: !ruby/object:Gem::Version
+  version: 3.0.4
+platform: ruby
+authors:
+- Applitools Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oily_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.46.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.46.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-doc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Applitools Ruby SDK
+email:
+- team@applitools.com
+executables: []
+extensions:
+- ext/eyes_core/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/eyes_core/extconf.rb
+- ext/eyes_core/eyes_core.c
+- ext/eyes_core/eyes_core.h
+- lib/applitools/capybara.rb
+- lib/applitools/chunky_png/resampling.rb
+- lib/applitools/chunky_png_patch.rb
+- lib/applitools/connectivity/proxy.rb
+- lib/applitools/connectivity/server_connector.rb
+- lib/applitools/core/app_environment.rb
+- lib/applitools/core/app_output.rb
+- lib/applitools/core/app_output_with_screenshot.rb
+- lib/applitools/core/argument_guard.rb
+- lib/applitools/core/batch_info.rb
+- lib/applitools/core/eyes_base.rb
+- lib/applitools/core/eyes_screenshot.rb
+- lib/applitools/core/fixed_cut_provider.rb
+- lib/applitools/core/fixed_scale_provider.rb
+- lib/applitools/core/helpers.rb
+- lib/applitools/core/location.rb
+- lib/applitools/core/match_result.rb
+- lib/applitools/core/match_results.rb
+- lib/applitools/core/match_window_data.rb
+- lib/applitools/core/match_window_task.rb
+- lib/applitools/core/mouse_trigger.rb
+- lib/applitools/core/rectangle_size.rb
+- lib/applitools/core/region.rb
+- lib/applitools/core/screenshot.rb
+- lib/applitools/core/session.rb
+- lib/applitools/core/session_start_info.rb
+- lib/applitools/core/test_results.rb
+- lib/applitools/core/text_trigger.rb
+- lib/applitools/core/trigger.rb
+- lib/applitools/extensions.rb
+- lib/applitools/eyes_logger.rb
+- lib/applitools/images/eyes.rb
+- lib/applitools/images/eyes_images_screenshot.rb
+- lib/applitools/method_tracer.rb
+- lib/applitools/sauce.rb
+- lib/applitools/utils/eyes_selenium_utils.rb
+- lib/applitools/utils/image_delta_compressor.rb
+- lib/applitools/utils/image_utils.rb
+- lib/applitools/utils/utils.rb
+- lib/applitools/version.rb
+- lib/eyes_core.rb
+homepage: https://www.applitools.com
+licenses:
+- Apache License, Version 2.0
+metadata:
+  yard.run: yri
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Applitools Ruby SDK
+test_files: []