eyes_core 3.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b1df68d352f994ee3111a658286083efd568c76
+  data.tar.gz: 4b7734495c6f07a2b63ee190f18cac3a064a23be
+SHA512:
+  metadata.gz: 3e568a25ce2eeeddb8ca7fcae76dbe037d963b30e738ce595b6a04a2681ec81aa34fc4fdbbceeddefb66c6ad429c0991fd416a63f1cc78d569c8fcae260a2738
+  data.tar.gz: 07adaf7c6c520f1d762d7ab42a1a3b18f14e4324e32c69fddb346ec6804dc5cde9d1e0a776c9a953b7a0ebbf4f09d2cc87152d7bc6a21e1b94c3186c527af469

data/ext/eyes_core/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS << ' -Wall'
+create_makefile('eyes_core/eyes_core')

data/ext/eyes_core/eyes_core.c

@@ -0,0 +1,80 @@
+#include "eyes_core.h"
+
+void Init_eyes_core() {
+  VALUE Applitools = rb_define_module("Applitools");
+  VALUE Resampling = rb_define_module_under(Applitools, "ResamplingFast");
+  rb_define_method(Resampling, "interpolate_cubic", c_interpolate_cubic, 1);
+  rb_define_method(Resampling, "merge_pixels", c_merge_pixels, 1);
+};
+
+
+VALUE c_interpolate_cubic(VALUE self, VALUE data) {
+  double t = NUM2DBL(rb_ary_entry(data, 1));
+  BYTE  new_r, new_g, new_b, new_a;
+  VALUE p0, p1, p2, p3;
+
+  p0 = NUM2UINT(rb_ary_entry(data, 2));
+  p1 = NUM2UINT(rb_ary_entry(data, 3));
+  p2 = NUM2UINT(rb_ary_entry(data, 4));
+  p3 = NUM2UINT(rb_ary_entry(data, 5));
+
+  new_r = interpolate_char(t, R_BYTE(p0), R_BYTE(p1), R_BYTE(p2), R_BYTE(p3));
+  new_g = interpolate_char(t, G_BYTE(p0), G_BYTE(p1), G_BYTE(p2), G_BYTE(p3));
+  new_b = interpolate_char(t, B_BYTE(p0), B_BYTE(p1), B_BYTE(p2), B_BYTE(p3));
+  new_a = interpolate_char(t, A_BYTE(p0), A_BYTE(p1), A_BYTE(p2), A_BYTE(p3));
+
+  return UINT2NUM(BUILD_PIXEL(new_r, new_g, new_b, new_a));
+};
+
+BYTE interpolate_char(double t, BYTE c0, BYTE c1, BYTE c2, BYTE c3) {
+  double a, b, c, d, res;
+  a = - 0.5 * c0 + 1.5 * c1 - 1.5 * c2 + 0.5 * c3;
+  b = c0 - 2.5 * c1 + 2 * c2 - 0.5 * c3;
+  c = 0.5 * c2 - 0.5 * c0;
+  d = c1;
+  res = a * t * t * t + b * t * t + c * t + d + 0.5;
+  if(res < 0) {
+    res = 0;
+  } else if(res > 255) {
+    res = 255;
+  };
+  return (BYTE)(res);
+};
+
+VALUE c_merge_pixels(VALUE self, VALUE pixels) {
+  unsigned int i, size, real_colors, acum_r, acum_g, acum_b, acum_a;
+  BYTE new_r, new_g, new_b, new_a;
+  PIXEL pix;
+
+  acum_r = 0;
+  acum_g = 0;
+  acum_b = 0;
+  acum_a = 0;
+
+  new_r = 0;
+  new_g = 0;
+  new_b = 0;
+  new_a = 0;
+
+  size = NUM2UINT(rb_funcall(pixels, rb_intern("size"), 0, Qnil)) - 1;
+  real_colors = 0;
+
+  for(i=1; i < size; i++) {
+    pix = NUM2UINT(rb_ary_entry(pixels, i));
+    if(A_BYTE(pix) != 0) {
+      acum_r += R_BYTE(pix);
+      acum_g += G_BYTE(pix);
+      acum_b += B_BYTE(pix);
+      acum_a += A_BYTE(pix);
+      real_colors += 1;
+    }
+  }
+
+  if(real_colors > 0) {
+    new_r = (BYTE)(acum_r/real_colors + 0.5);
+    new_g = (BYTE)(acum_g/real_colors + 0.5);
+    new_b = (BYTE)(acum_b/real_colors + 0.5);
+  }
+  new_a = (BYTE)(acum_a/(size - 1) + 0.5);
+  return UINT2NUM(BUILD_PIXEL(new_r, new_g, new_b, new_a));
+}

data/ext/eyes_core/eyes_core.h

@@ -0,0 +1,24 @@
+#ifndef APPLITOOLS_RESAMPLING_EXT
+#define APPLITOOLS_RESAMPLING_EXT
+#include "ruby.h"
+
+typedef uint32_t PIXEL; // Pixels use 32 bits unsigned integers
+typedef unsigned char BYTE; // Bytes use 8 bits unsigned integers
+
+#define R_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0xff000000) >> 24))
+#define G_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x00ff0000) >> 16))
+#define B_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x0000ff00) >> 8))
+#define A_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x000000ff)))
+
+#define BUILD_PIXEL(r, g, b, a)  (((PIXEL) (r) << 24) + ((PIXEL) (g) << 16) + ((PIXEL) (b) << 8) + (PIXEL) (a))
+#define INT8_MULTIPLY(a, b)      (((((a) * (b) + 0x80) >> 8) + ((a) * (b) + 0x80)) >> 8)
+
+
+
+void Init_resampling();
+
+VALUE c_interpolate_cubic(VALUE,VALUE);
+VALUE c_merge_pixels(VALUE, VALUE);
+BYTE interpolate_char(double, BYTE, BYTE, BYTE, BYTE);
+
+#endif

data/lib/applitools/capybara.rb

@@ -0,0 +1,8 @@
+require 'capybara'
+
+Applitools.require_dir 'selenium/capybara'
+
+module Applitools
+  extend Applitools::Selenium::Capybara::CapybaraSettings
+  register_capybara_driver
+end

data/lib/applitools/chunky_png/resampling.rb

@@ -0,0 +1,148 @@
+module Applitools::ChunkyPNG
+  module Resampling
+    def resample_bicubic!(dst_width, dst_height)
+      w_m = [1, width / dst_width].max
+      h_m = [1, height / dst_height].max
+
+      dst_width2 = dst_width * w_m
+      dst_height2 = dst_height * h_m
+
+      points = bicubic_x_points(dst_width2)
+      pixels = Array.new(points.size)
+
+      points.each do |interpolation_data|
+        pixels[interpolation_data[0]] = interpolate_cubic(interpolation_data)
+      end
+      replace_canvas!(dst_width2, height, pixels)
+
+      points = bicubic_y_points(dst_height2)
+      pixels = Array.new(points.size)
+
+      points.each do |interpolation_data|
+        pixels[interpolation_data[0]] = interpolate_cubic(interpolation_data)
+      end
+      replace_canvas!(dst_width2, dst_height2, pixels)
+
+      return self unless w_m * h_m > 1
+
+      points = scale_points(dst_width, dst_height, w_m, h_m)
+      pixels = Array.new(points.size)
+
+      points.each do |merge_data|
+        pixels[merge_data[0]] = merge_pixels(merge_data)
+      end
+
+      replace_canvas!(dst_width, dst_height, pixels)
+    end
+
+    def resample_bicubic(new_width, new_height)
+      dup.resample_bicubic!(new_width, new_height)
+    end
+
+    def bicubic_x_points(dst_width)
+      bicubic_points(width, dst_width, false)
+    end
+
+    def bicubic_y_points(dst_height)
+      bicubic_points(height, dst_height, true)
+    end
+
+    def bicubic_points(src_dimension, dst_dimension, direction, y_start_position = 0)
+      step = (src_dimension - 1).to_f / dst_dimension
+      y_bounds = direction ? width : height
+      raise ArgumentError.new 'Start position value is invalid!' unless y_start_position < y_bounds
+      pixels_size = (y_bounds - y_start_position) * dst_dimension
+
+      steps = Array.new(dst_dimension)
+      residues = Array.new(dst_dimension)
+
+      (0..dst_dimension - 1).each do |i|
+        steps[i] = (i * step).to_i
+        residues[i] = i * step - steps[i]
+      end
+      Enumerator.new(pixels_size) do |enum|
+        (y_start_position..y_bounds - 1).each do |y|
+          line = (direction ? column(y) : row(y))
+
+          line_with_bounds = [imaginable_point(line[0], line[1])] + line + [
+            imaginable_point(line[src_dimension - 2], line[src_dimension - 3]),
+            imaginable_point(line[src_dimension - 1], line[src_dimension - 2])
+          ]
+
+          index_y = dst_dimension * y
+          (0..dst_dimension - 1).each do |x|
+            index = direction ? y_bounds * x + y : index_y + x
+            enum << ([index, residues[x]] + line_with_bounds.last(src_dimension + 3 - steps[x]).first(4))
+          end
+        end
+      end
+    end
+
+    def scale_points(dst_width, dst_height, w_m, h_m)
+      Enumerator.new(dst_width * dst_height) do |enum|
+        (0..dst_height - 1).each do |i|
+          (0..dst_width - 1).each do |j|
+            pixels_to_merge = []
+            (0..h_m - 1).each do |y|
+              y_pos = i * h_m + y
+              (0..w_m - 1).each do |x|
+                x_pos = j * w_m + x
+                pixels_to_merge << get_pixel(x_pos, y_pos)
+              end
+            end
+            index = i * dst_width + j
+            enum << ([index] + pixels_to_merge)
+          end
+        end
+      end
+    end
+
+    def merge_pixels(merge_data)
+      pixels = merge_data[1..merge_data.size]
+      merged_data = pixels.each_with_object(r: 0, g: 0, b: 0, a: 0, real_colors: 0) do |pixel, result|
+        unless ChunkyPNG::Color.fully_transparent?(pixel)
+          result[:real_colors] += 1
+          [:r, :g, :b].each do |ch|
+            result[ch] += ChunkyPNG::Color.send(ch, pixel)
+          end
+        end
+        result[:a] += ChunkyPNG::Color.a(pixel)
+        result
+      end
+
+      r = merged_data[:real_colors] > 0 ? merged_data[:r] / merged_data[:real_colors] : 0
+      g = merged_data[:real_colors] > 0 ? merged_data[:g] / merged_data[:real_colors] : 0
+      b = merged_data[:real_colors] > 0 ? merged_data[:b] / merged_data[:real_colors] : 0
+      a = merged_data[:a] / pixels.size
+
+      ChunkyPNG::Color.rgba(r, g, b, a)
+    end
+
+    def interpolate_cubic(data)
+      result = {}
+      t = data[1]
+      [:r, :g, :b, :a].each do |chan|
+        c0 = ChunkyPNG::Color.send(chan, data[2])
+        c1 = ChunkyPNG::Color.send(chan, data[3])
+        c2 = ChunkyPNG::Color.send(chan, data[4])
+        c3 = ChunkyPNG::Color.send(chan, data[5])
+
+        a = -0.5 * c0 + 1.5 * c1 - 1.5 * c2 + 0.5 * c3
+        b = c0 - 2.5 * c1 + 2 * c2 - 0.5 * c3
+        c = 0.5 * c2 - 0.5 * c0
+        d = c1
+
+        result[chan] = [0, [255, (a * t**3 + b * t**2 + c * t + d).to_i].min].max
+      end
+      ChunkyPNG::Color.rgba(result[:r], result[:g], result[:b], result[:a])
+    end
+
+    def imaginable_point(point1, point2)
+      r = [0, [255, ChunkyPNG::Color.r(point1) << 1].min - ChunkyPNG::Color.r(point2)].max
+      g = [0, [255, ChunkyPNG::Color.g(point1) << 1].min - ChunkyPNG::Color.g(point2)].max
+      b = [0, [255, ChunkyPNG::Color.b(point1) << 1].min - ChunkyPNG::Color.b(point2)].max
+      a = [0, [255, ChunkyPNG::Color.a(point1) << 1].min - ChunkyPNG::Color.a(point2)].max
+      ChunkyPNG::Color.rgba(r, g, b, a)
+    end
+  end
+end

data/lib/applitools/chunky_png_patch.rb

@@ -0,0 +1,8 @@
+require 'oily_png'
+require_relative 'chunky_png/resampling'
+require 'eyes_core/eyes_core'
+
+ChunkyPNG::Canvas.class_eval do
+  include Applitools::ChunkyPNG::Resampling
+  include Applitools::ResamplingFast
+end

data/lib/applitools/connectivity/proxy.rb

@@ -0,0 +1,3 @@
+module Applitools::Connectivity
+  Proxy = Struct.new(:uri, :user, :password)
+end

data/lib/applitools/connectivity/server_connector.rb

@@ -0,0 +1,118 @@
+require 'faraday'
+require 'oj'
+Oj.default_options = { :mode => :compat }
+
+require 'uri'
+
+module Applitools::Connectivity
+  module ServerConnector
+    extend self
+
+    DEFAULT_SERVER_URL = 'https://eyessdk.applitools.com'.freeze
+
+    SSL_CERT = File.join(File.dirname(File.expand_path(__FILE__)), '../../../certs/cacert.pem').to_s.freeze
+    DEFAULT_TIMEOUT = 300
+
+    API_SESSIONS_RUNNING = '/api/sessions/running/'.freeze
+
+    HTTP_STATUS_CODES = {
+      created: 201,
+      accepted: 202
+    }.freeze
+
+    attr_accessor :server_url, :api_key
+    attr_reader :endpoint_url
+    attr_accessor :proxy
+
+    def server_url=(url)
+      @server_url = url.nil? ? DEFAULT_SERVER_URL : url
+      unless @server_url.is_a? String
+        raise Applitools::EyesIllegalArgument.new 'You should pass server url as a String!' \
+          " (#{@server_url.class} is passed)"
+      end
+      @endpoint_url = URI.join(@server_url, API_SESSIONS_RUNNING).to_s
+    end
+
+    def set_proxy(uri, user = nil, password = nil)
+      self.proxy = Proxy.new uri, user, password
+    end
+
+    def match_window(session, data)
+      # Notice that this does not include the screenshot.
+      json_data = Oj.dump(Applitools::Utils.camelcase_hash_keys(data.to_hash)).force_encoding('BINARY')
+      body = [json_data.length].pack('L>') + json_data + data.screenshot
+      Applitools::EyesLogger.debug 'Sending match data...'
+      res = post(URI.join(endpoint_url, session.id.to_s), content_type: 'application/octet-stream', body: body)
+      raise Applitools::EyesError.new("Request failed: #{res.status}") unless res.success?
+      Applitools::MatchResult.new Oj.load(res.body)
+    end
+
+    def start_session(session_start_info)
+      res = post(endpoint_url, body: Oj.dump(startInfo:
+                                                 Applitools::Utils.camelcase_hash_keys(session_start_info.to_hash)))
+      raise Applitools::EyesError.new("Request failed: #{res.status}") unless res.success?
+
+      response = Oj.load(res.body)
+      Applitools::Session.new(response['id'], response['url'], res.status == HTTP_STATUS_CODES[:created])
+    end
+
+    def stop_session(session, aborted = nil, save = false)
+      res = long_delete(URI.join(endpoint_url, session.id.to_s), query: { aborted: aborted, updateBaseline: save })
+      raise Applitools::EyesError.new("Request failed: #{res.status}") unless res.success?
+
+      response = Oj.load(res.body)
+      Applitools::TestResults.new(response)
+    end
+
+    private
+
+    DEFAULT_HEADERS = {
+      'Accept' => 'application/json',
+      'Content-Type' => 'application/json'
+    }.freeze
+
+    LONG_REQUEST_DELAY = 2 # seconds
+    MAX_LONG_REQUEST_DELAY = 10 # seconds
+    LONG_REQUEST_DELAY_MULTIPLICATIVE_INCREASE_FACTOR = 1.5
+
+    [:get, :post, :delete].each do |method|
+      define_method method do |url, options = {}|
+        request(url, method, options)
+      end
+
+      define_method "long_#{method}" do |url, options = {}|
+        long_request(url, method, options)
+      end
+    end
+
+    def request(url, method, options = {})
+      Faraday::Connection.new(url, ssl: { ca_file: SSL_CERT }, proxy: @proxy || nil).send(method) do |req|
+        req.options.timeout = DEFAULT_TIMEOUT
+        req.headers = DEFAULT_HEADERS.merge(options[:headers] || {})
+        req.headers['Content-Type'] = options[:content_type] if options.key?(:content_type)
+        req.params = { apiKey: api_key }.merge(options[:query] || {})
+        req.body = options[:body]
+      end
+    end
+
+    def long_request(url, method, options = {})
+      delay = LONG_REQUEST_DELAY
+      (options[:headers] ||= {})['Eyes-Expect'] = '202-accepted'
+
+      loop do
+        # Date should be in RFC 1123 format.
+        options[:headers]['Eyes-Date'] = Time.now.utc.strftime('%a, %d %b %Y %H:%M:%S GMT')
+
+        res = request(url, method, options)
+        return res unless res.status == HTTP_STATUS_CODES[:accepted]
+
+        Applitools::EyesLogger.debug "Still running... retrying in #{delay}s"
+        sleep delay
+
+        delay = [MAX_LONG_REQUEST_DELAY, (delay * LONG_REQUEST_DELAY_MULTIPLICATIVE_INCREASE_FACTOR).round].min
+      end
+    end
+
+    include Applitools::MethodTracer
+  end
+end

data/lib/applitools/core/app_environment.rb

@@ -0,0 +1,29 @@
+module Applitools
+  class AppEnvironment
+    attr_accessor :os, :hosting_app, :display_size, :inferred_environment
+
+    def initialize(options = {})
+      @os = options[:os]
+      @hosting_app = options[:hosting_app]
+      @display_size = options[:display_size]
+      @inferred = options[:inferred]
+    end
+
+    def to_hash
+      {
+        os: @os,
+        hosting_app: @hosting_app,
+        display_size: @display_size.to_hash,
+        inferred: @inferred
+      }
+    end
+
+    def to_s
+      result = ''
+      to_hash.each_pair do |k, v|
+        result << "#{k}: #{v}; "
+      end
+      result
+    end
+  end
+end

data/lib/applitools/core/app_output.rb

@@ -0,0 +1,17 @@
+module Applitools
+  class AppOutput
+    attr_reader :title, :screenshot64
+
+    def initialize(title, screenshot64)
+      @title = title
+      @screenshot64 = screenshot64
+    end
+
+    def to_hash
+      {
+        title: title,
+        screenshot64: ''
+      }
+    end
+  end
+end