eyes_core 6.7.1 → 6.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e8270b52cdd58ec5d01252e085200ba62f8c9b9c056cfb6a5f217f58003f2a5
-  data.tar.gz: 8f01ec47b288f64c84aad4d7684d691a52376fc635014e059ecab49b3dec76ce
+  metadata.gz: e6af30db71471bb3da822c2a0088d5b8cb60f6a7810e812b3586a5a5c2be4ed2
+  data.tar.gz: c7805e2b0749179bc418119253568d2982181b25807f03627c18a6d905162111
 SHA512:
-  metadata.gz: d78fa4f0fc03842d096f0af4fb7cca76b4416176fd0cdb84b30d34ef90d9bef40c839a8093197a0f111ac1e8ae1a6764df697b09850350824b5e40cd819e7f55
-  data.tar.gz: 9cd38ffa78203fdfb4615259a3d426f30bf8178f112e5c56d6f992d23be14cad0bdc6d5d9fca7ff840e5ef54fcad8e05e249161f2a619bf6e7b57e126b61c3f2
+  metadata.gz: 236951c25c7347f813862b6acad69e8ef905cc80acffe53c16789e2d79082059063d111988ba5d84549ef5cf733000d0857c39b06a2f2dbe04489caefe9d1eed
+  data.tar.gz: 6cf0d540fa2b61fbd318a6ee52ba02e86533d09e4ea9c76fbbf8bd047bc5d94ef06e947899f77b625e2c80e8e6203a9a2e5d2590a8b19f6a94c65d672b6461fc

data/CHANGELOG.md

@@ -1,5 +1,83 @@
 # Changelog
 
+## [6.7.2](https://github.com/Applitools-Dev/sdk/compare/ruby/eyes_core@6.7.1...ruby/eyes_core@6.7.2) (2025-06-15)
+
+
+### Dependencies
+
+* @applitools/dom-snapshot bumped to 4.11.22
+  #### Bug Fixes
+
+  * css media query group conditions | FLD-3151 ([#3023](https://github.com/Applitools-Dev/sdk/issues/3023)) ([56ec107](https://github.com/Applitools-Dev/sdk/commit/56ec107bcda6a5a330d19c278267d73de5d86d8b))
+
+
+
+* @applitools/nml-client bumped to 1.9.5
+  #### Bug Fixes
+
+  * nml-client depends on core-base ([#2995](https://github.com/Applitools-Dev/sdk/issues/2995)) ([1f7cf69](https://github.com/Applitools-Dev/sdk/commit/1f7cf6930709a40a498dd1f525132648aa593af0))
+
+
+
+* @applitools/tunnel-client bumped to 1.8.0
+  #### Features
+
+  * update build script to include individual zip creation ([#3008](https://github.com/Applitools-Dev/sdk/issues/3008)) ([46a0cfc](https://github.com/Applitools-Dev/sdk/commit/46a0cfcc472ab69384560095d90a7fa58b4b9186))
+
+
+
+* @applitools/ufg-client bumped to 1.16.12
+  #### Bug Fixes
+
+  * remove safari-early-access browser version for js sdks | AD-10226 ([#3034](https://github.com/Applitools-Dev/sdk/issues/3034)) ([7ca09f5](https://github.com/Applitools-Dev/sdk/commit/7ca09f5c0c271570142058ea766533b86434dc2e))
+
+
+
+* @applitools/core bumped to 4.40.0
+  #### Features
+
+  * update build script to include individual zip creation ([#3008](https://github.com/Applitools-Dev/sdk/issues/3008)) ([46a0cfc](https://github.com/Applitools-Dev/sdk/commit/46a0cfcc472ab69384560095d90a7fa58b4b9186))
+
+
+  #### Bug Fixes
+
+  * css media query group conditions | FLD-3151 ([#3023](https://github.com/Applitools-Dev/sdk/issues/3023)) ([56ec107](https://github.com/Applitools-Dev/sdk/commit/56ec107bcda6a5a330d19c278267d73de5d86d8b))
+  * export issues for ts js with legacy solution ([#3016](https://github.com/Applitools-Dev/sdk/issues/3016)) ([a3a9daf](https://github.com/Applitools-Dev/sdk/commit/a3a9daf9c3361bb1f253499c1335a1434ec520d1))
+  * extractLatestCommitInfo | FLD-3217 ([#3039](https://github.com/Applitools-Dev/sdk/issues/3039)) ([3f72a23](https://github.com/Applitools-Dev/sdk/commit/3f72a230fa0166046ea85ae004cfb544de86e628))
+  * handle error when sending started message in tunnel manager server ([#3019](https://github.com/Applitools-Dev/sdk/issues/3019)) ([2cdaad8](https://github.com/Applitools-Dev/sdk/commit/2cdaad896fd679187449b69abe529b006f6255ee))
+
+
+
+* @applitools/req bumped to 1.7.13
+
+* @applitools/dom-capture bumped to 11.5.6
+
+* @applitools/spec-driver-webdriver bumped to 1.2.6
+
+* @applitools/screenshoter bumped to 3.11.5
+
+* @applitools/core-base bumped to 1.25.4
+  #### Bug Fixes
+
+  * Differentiate Between Invalid and Missing API Key Errors ([6ac17d4](https://github.com/Applitools-Dev/sdk/commit/6ac17d40d7aff45b3de5c949dc7d4673b9739bfd))
+  * export issues for ts js with legacy solution ([#3016](https://github.com/Applitools-Dev/sdk/issues/3016)) ([a3a9daf](https://github.com/Applitools-Dev/sdk/commit/a3a9daf9c3361bb1f253499c1335a1434ec520d1))
+
+
+
+* @applitools/ec-client bumped to 1.10.15
+
+* @applitools/test-server bumped to 1.2.3
+  #### Bug Fixes
+
+  * basic auth protected resources | FLD-2761 | FMRI-120 ([#2444](https://github.com/Applitools-Dev/sdk/issues/2444)) ([b48cf49](https://github.com/Applitools-Dev/sdk/commit/b48cf49dec50bbf1ed2ba111608a48cf09962565))
+  * export issues for ts js with legacy solution ([#3016](https://github.com/Applitools-Dev/sdk/issues/3016)) ([a3a9daf](https://github.com/Applitools-Dev/sdk/commit/a3a9daf9c3361bb1f253499c1335a1434ec520d1))
+  * storybook navigation timeouts ([#2701](https://github.com/Applitools-Dev/sdk/issues/2701)) ([64e3a40](https://github.com/Applitools-Dev/sdk/commit/64e3a40a524ae76ec457ae9c2d1170fbaea5e982))
+
+
+
+* eyes_universal bumped to 4.40.0
+
+
 ## [6.7.1](https://github.com/Applitools-Dev/sdk/compare/ruby/eyes_core@6.7.0...ruby/eyes_core@6.7.1) (2025-05-22)
 
 

data/LICENSE

@@ -0,0 +1,26 @@
+-  -
+SDK LICENSE AGREEMENT
+IMPORTANT - PLEASE READ CAREFULLY THE TERMS OF THIS LICENSE AGREEMENT ("AGREEMENT"). BY INSTALLING, ACCESSING AND/OR USING THE SOFTWARE (AS DEFINED BELOW), YOU EXPRESSLY ACKNOWLEDGE AND AGREE THAT YOU, OR THE COMPANY YOU REPRESENT, ("YOU" OR "LICENSEE") ARE ENTERING INTO A LEGAL AGREEMENT WITH APPLITOOLS LTD. AND ITS AFFILIATES ("APPLITOOLS"), AND HAVE UNDERSTOOD AND AGREE TO COMPLY WITH, AND BE LEGALLY BOUND BY, THE TERMS AND CONDITIONS OF THIS AGREEMENT. YOU HEREBY WAIVE ANY RIGHTS OR REQUIREMENTS UNDER ANY LAWS OR REGULATIONS IN ANY JURISDICTION WHICH REQUIRE AN ORIGINAL (NON-ELECTRONIC) SIGNATURE OR DELIVERY OR RETENTION OF NON-ELECTRONIC RECORDS, TO THE EXTENT PERMITTED UNDER APPLICABLE LAW.
+THE SOFTWARE MAY BE USED SOLELY FOR YOUR PERSONAL, NON-COMMERCIAL PURPOSES. FOR COMMERCIAL PURPOSES PLEASE CONTACT THE REGIONAL APPLITOOLS BUSINESS REPRESENTATIVE.
+1. Definitions. For purposes of this Agreement, the following capitalized terms shall have the following meaning:
+   1. "Documentation" means the user's guides and technical manuals delivered by Applitools to Licensee.
+   2.  "Feedback" means suggestions, comments or feedback (whether orally or in writing) with respect to the Software.
+   3. "Intellectual Property Rights" means all intangible legal rights, titles and interests evidenced by or embodied in all: (i) inventions (regardless of patentability and whether or not reduced to practice), improvements thereto, patents, patent applications, patent disclosures, together with all reissuances, continuations, continuations in part, revisions, extensions and reexaminations thereof; (ii) trademarks, service marks, trade dress, logos, trade names, corporate names, together with translations, adaptations, derivations and combinations thereof, including goodwill associated therewith, and applications, registrations, and renewals in connection therewith; (iii) any work of authorship, regardless of copyrightable, copyrightable works, copyrights (including moral rights), and applications, registrations and renewals in connection therewith; (iv) mask works and applications, registrations and renewals in connection therewith; (v) trade secrets and Confidential Information; and (vi) other proprietary rights and any other similar rights, in each case on a worldwide basis, and copies and tangible embodiments thereof, in whatever form or medium.
+   4. "License" means the right to use the Software pursuant to Section ‎2.1 to this Agreement.
+   5.  "Software" means Applitools' software development kit software in object or source code version, Documentation and any updates and upgrade thereto (to the extent delivered).
+1. License
+   1. Grant of License. Subject to the terms and conditions of this Agreement, Applitools grants You, during the Term, a personal, non-exclusive, non-sublicensable, non-transferable, revocable license to: (i) use the Software solely for Your own personal (non-commercial) use and (ii) use and display Applitools' Marks solely for the purpose of publicizing or advertising that You are using the Software.
+   2. Documentation. Applitools may make available Documentation to Licensee for Licensee to use solely in connection with Licensee's use of the Software during the term of this Agreement. Licensee may print or copy the Documentation as needed for its own purposes provided that all copyright notices are included therein. The Documentation shall be considered the Confidential Information of Applitools.
+   1. Reservation of Rights; Use Restrictions. Other than the rights explicitly granted in this Agreement, Licensee shall have no other rights, express or implied, in the Software. Without limiting the generality of the foregoing, Licensee agrees and undertakes not to: (i) allow any third party to use the Software in any manner, including but not limited to, sell, lease, sublicense or distribute the Software, or any part thereof; (ii) modify, revise, or alter the Software or reverse engineer, decompile, disassemble or otherwise reduce to human-perceivable form the Software's source code; (iii) copy or allow copies of the Software to be made; (iv) remove, alter or obscure any proprietary notice or identification, including copyright, trademark, patent or other notices, contained in or displayed on or via the Software; (v) use the Software to violate any applicable laws, rules or regulations, or for any unlawful, harmful, irresponsible, or inappropriate purpose, or in any manner that breaches this Agreement, and/or (vi) represent that it possesses any proprietary interest in the Software.
+   1. Third Party Software. Licensee acknowledges and agrees that any third party software ("Third Party Software") that provided with the Software is provided under the terms of the license attached/linked thereto or, if no such license is attached, such Third Party Software is provided for free and on "AS IS" basis. Applitools is not liable for any losses or damages which may occur resulting from the use of any Third Party Software. Applitools does not possess any proprietary interest in such Third Party Software.
+   1. Open Source Licenses. The Software includes certain open source code software and materials (as shall be listed in the documentation of the Software) ("Open Source Software") that are subject to their respective open source licenses ("Open Source Licenses"). Such Open Source Licenses contain a list of conditions with respect to warranty, copyright policy and other provisions. By executing this Agreement, Licensee undertakes to strictly comply with the terms and condition of the Open Source Licenses, as may be amended from time to time. In order to comply with the Open Source Licenses, Licensee shall read the respective licenses or notices, such list of Open Source Licenses may be amended from time to time by Applitools, at its sole discretion. In the event of any inconsistencies or conflicting provisions between the provisions of the Open Source Licenses and the provisions of this Agreement, the provisions of the Open Source Licenses shall prevail. Without derogating from the generality of the foregoing, it is clarified that any Open Source Software is provided on an "AS IS" basis, without indemnity or warranty of any kind, whether express or implied. For clarity, the representations and warranties set forth in Section ‎4 hereunder shall not apply to any Open Source Software.
+1. Title & Ownership. APPLITOOLS DOES NOT SELL OR TRANSFER TITLE IN THE SOFTWARE, OR ANY PART THEREOF, TO LICENSEE. The Documentation, Software (excluding any Open Source Software and Third Party Software therein which are owned by their respective licensors) and/or any copies thereof, including without limitation any derivative works made (regardless of whether such derivative works were made and/or developed pursuant to the request and/or specifications of Licensee, and irrespective of any support and/or assistance Applitools may, will or had received from Licensee, or any third party on its behalf, with respect thereto), as well as any updates or upgrades thereto, if provided to Applitools pursuant to this Agreement, shall remain Applitools' sole and exclusive property. All Intellectual Property Rights evidenced by or embodied in and/or attached/connected/related to the Software, or part thereof, are and shall be owned solely and exclusively by Applitools. Nothing in this Agreement shall constitute a waiver of Applitools' Intellectual Property Rights under any law, or be in any way construed or interpreted as such. It is further agreed that to the extent Licensee provides Applitools with Feedback, Licensee acknowledges that any and all rights, including Intellectual Property Rights in such Feedback shall belong exclusively to Applitools and Licensee hereby irrevocably and unconditionally transfers and assigns to Applitools all intellectual property rights in such Feedback and waives any and all moral rights that Licensee may have in respect thereto. It is further understood that use of Feedback, if any, may be made by Applitools at its sole discretion, and that Applitools in no way shall be obliged to make use of any kind of the Feedback or part thereof.
+1. Warranty. Applitools warrants that to its knowledge it has the right to grant the license under this Agreement. Applitools' sole liability for any breach of this warranty or any other warranty under this Agreement shall be, at Applitools' sole discretion: (i) to replace or repair the Software or the applicable portion thereof; or (ii) to terminate this Agreement.
+2. Warranty Exclusions. The warranties set forth in Section ‎4 are contingent upon Licensee's proper use of the Software, and shall not apply to damage caused by abuse, misuse, alteration, neglect or unauthorized repair or installation, or by the use or attempted use of Software other than that supplied and supported by Applitools. Applitools will use reasonable commercial efforts to repair or replace the Software or the applicable portion thereof, pursuant to the foregoing warranty within thirty (30) days of being so notified.
+1. Warranty Disclaimers. AS BETWEEN LICENSEE AND APPLITOOLS, EXCEPT AS SET IN SECTION ‎4, THE SOFTWARE IS PROVIDED ON AN "AS IS" AND "AS AVAILABLE" BASIS WITHOUT WARRANTIES OF ANY KIND INCLUDING, WITHOUT LIMITATION, REPRESENTATIONS, WARRANTIES AND CONDITIONS OF MERCHANTABILITY, FITNESS FOR INTENDED OR PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, THAT THE SOFTWARE WILL MEET LICENSEE'S REQUIREMENTS OR EXPECTATIONS OR WILL ACHIEVE ANY SPECIFIC RESULTS AND THOSE ARISING BY STATUTE OR FROM A COURSE OF DEALING OR USAGE OF TRADE. Applicable law may not allow the exclusion of certain warranties, so to that extent such exclusions may not apply.
+1. High Risk Activities. You acknowledge that the Software is not fault tolerant and is not designed, manufactured, or intended for use or resale as on-line control equipment in hazardous or high risk environments and activities requiring fail-safe performance (such as in the operation of nuclear facilities, aircraft navigation or communication systems, air traffic control, direct life support machines and/or devices, or weapons systems) in which the failure of the Software could lead directly to death, personal injury, or severe physical or environmental damage, and You agree not to use or allow the use of the Software or any portion thereof for, or in connection with, any such environment or activity.
+1. Indemnify. You agree that Applitools shall have no liability whatsoever for any use made of the Software by You or any third party. You hereby agree to defend, indemnify and hold harmless Applitools and its affiliates and their respective officers, directors, agents and employees from any and all claims, damages, liabilities, costs, and expenses (including attorney's fees) arising from claims related to Your use of the Software as well as from Your failure to comply with this Agreement.
+1. Limitation of Liability. UNDER NO CIRCUMSTANCES SHALL APPLITOOLS AND/OR ITS AFFILIATES BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, OR FOR ANY LOSS OF DATA, REVENUE, BUSINESS OR REPUTATION, THAT ARISES UNDER OR IN CONNECTION WITH THIS AGREEMENT, OR THAT RESULTS FROM THE USE OF, OR THE INABILITY TO USE, THE SOFTWARE. APPLITOOLS'S TOTAL AGGREGATE LIABILITY FOR ANY AND ALL DIRECT DAMAGES AND LOSSES THAT ARISE UNDER OR IN CONNECTION WITH THIS AGREEMENT SHALL NOT IN ANY CIRCUMSTANCE EXCEED THE AMOUNT OF 100.00 (ONE HUNDRED) UNITED STATES DOLLARS. THE FOREGOING LIMITATIONS AND EXCLUSIONS IN THIS SECTION ‎7 SHALL APPLY: (I) EVEN IF APPLITOOLS HAS BEEN ADVISED OF THE POSSIBILITY OF ANY DAMAGES OR LOSSES; (II) EVEN IF ANY REMEDY SET FORTH HEREIN FAILS OF ITS ESSENTIAL PURPOSE; AND (III) REGARDLESS OF THE BASIS OR THEORY OF LIABILITY.
+1. Export Laws. Licensee agrees to comply fully with all U.S., EU, Israeli, and all applicable export laws and regulations to ensure that neither the Software nor any technical data related thereto are exported or re-exported directly or indirectly in violation of, or used for any purposes prohibited by, such laws and regulations. For clarity, and without derogating from Section ‎11 below, in case of any change of any applicable law, policy or regulation, which might affect Applitools' business, Applitools will have the right to terminate this Agreement and the license granted hereunder and the Licensee shall have no claims regarding such termination.
+1. Term and Termination. This Agreement shall continue until terminated as set forth in this section (the "Term"). You may terminate this Agreement at any time by removing the Software from Your system and destroying all copies of the Software and Documentation relating to the Software. Unauthorized copying of the Software or otherwise failing to comply with this Agreement will result in automatic immediate termination of this Agreement and will make available to Applitools legal remedies. Applitools reserves the right to terminate this Agreement and the License at any time and without notice. Upon termination of this Agreement, the License will terminate and You: (i) will cease any and all rights to use the Software, and (ii) will remove the Software from all hard drives, networks and other storage media and destroy all copies of the Software in your possession or under your control. The provisions of Sections ‎2.3, ‎2.4, ‎2.5, ‎6, ‎7, ‎8, ‎9, 10, ‎11 and ‎12 shall survive the termination, expiration or other ending of this Agreement.
+1. Miscellaneous. This Agreement represents the complete agreement concerning the Software between You and Applitools and supersedes all prior agreements and representations between You and Applitools. If any provision of this Agreement is held to be unenforceable for any reason, such provision shall be reformed only to the extent necessary to make it enforceable. Any waiver of any provision of this Agreement will be effective only if in writing and signed by Applitools. This Agreement is personal to You and may not be assigned or transferred for any reason whatsoever without the consent of Applitools and any action or conduct in violation of the foregoing shall be void and without effect. Applitools expressly reserves the right to assign this Agreement and to delegate any of its obligations hereunder. This Agreement are governed by and construed under the laws of the State of Israel, excluding its conflicts of law rules. You expressly agree that the exclusive jurisdiction for any claim or action arising out of or relating to this Agreement shall be the courts located in Tel Aviv, Israel, and You further agree and submit to the exercise of personal jurisdiction of such courts for the purpose of litigating any such claim or action. In any action or proceeding to enforce rights under this Agreement, the prevailing party shall be entitled to recover costs and attorneys' fees.

data/README.md

@@ -0,0 +1,402 @@
+# Applitools Eyes Core SDK
+
+[![Gem Version](https://badge.fury.io/rb/eyes_core.svg)](https://badge.fury.io/rb/eyes_core)
+
+The `eyes_core` gem is the foundation of the Applitools Eyes Ruby SDK ecosystem. It provides the core functionality, base classes, and utilities that power all specialized Applitools SDKs for Ruby.
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Installation](#installation)
+3. [Core Components](#core-components)
+   - [EyesBase](#eyesbase)
+   - [Configuration](#configuration)
+   - [Viewport Size](#viewport-size)
+   - [Batch Info](#batch-info)
+   - [Region](#region)
+   - [Match Settings](#match-settings)
+4. [Universal SDK Integration](#universal-sdk-integration)
+5. [Error Handling](#error-handling)
+6. [Advanced Features](#advanced-features)
+   - [Accessibility Testing](#accessibility-testing)
+   - [Layout Breakpoints](#layout-breakpoints)
+   - [Proxy Configuration](#proxy-configuration)
+7. [Best Practices](#best-practices)
+8. [Troubleshooting](#troubleshooting)
+9. [FAQ](#faq)
+
+## Overview
+
+The `eyes_core` gem serves as the foundation for all Applitools Ruby SDKs. While not intended for direct use, it provides essential functionality that enables visual testing across different platforms and frameworks.
+
+### Core Capabilities
+
+- **Configuration Management**: Centralized settings for all Eyes operations
+- **Server Communication**: Handles API interactions with Applitools services
+- **Data Structures**: Common models for regions, batches, and test results
+- **Visual Validation Primitives**: Base implementation for visual comparisons
+- **Universal SDK Integration**: Connects to the cross-platform Universal SDK
+- **Utility Functions**: Shared helpers for geometry, image processing, and more
+
+## Installation
+
+The `eyes_core` gem is automatically installed as a dependency when you install any of the specific Eyes SDK implementations. You typically don't need to install it directly.
+
+```ruby
+# Installing a specific SDK automatically includes eyes_core
+gem install eyes_selenium
+gem install eyes_images
+gem install eyes_capybara
+gem install eyes_appium
+
+# Or add to your Gemfile
+gem 'eyes_selenium'  # This will include eyes_core as a dependency
+```
+
+> **Note**: Direct installation of `eyes_core` is only needed if you're building a custom integration or extending the SDK functionality.
+
+## Core Components
+
+### EyesBase
+
+The `EyesBase` class is the foundation of all Eyes SDK implementations. It provides the core functionality for:
+
+- Opening and closing tests
+- Performing visual validations
+- Managing test configurations
+- Communicating with the Applitools server
+
+Key methods include:
+
+```ruby
+# Opening a test
+open_base(options = {})
+
+# Core validation method (used by specific implementations)
+check_window_base(region_provider, retry_timeout, match_window_data)
+
+# Closing a test and getting results
+close(throw_exception = true, be_silent = false)
+
+# Aborting a test
+abort_if_not_closed
+```
+
+### Configuration
+
+The `EyesBaseConfiguration` class manages all test settings. Key configurations include:
+
+```ruby
+# Basic test information
+config.app_name = "My Application"
+config.test_name = "My Test"
+config.viewport_size = Applitools::RectangleSize.new(1024, 768)
+
+# Authentication
+config.api_key = "YOUR_API_KEY"
+config.server_url = "https://eyesapi.applitools.com" # Default server
+
+# Test organization
+config.batch = Applitools::BatchInfo.new("My Batch")
+config.branch_name = "feature/branch"
+config.parent_branch_name = "master"
+
+# Match settings
+config.match_level = Applitools::MatchLevel::STRICT
+config.match_timeout = 5 # seconds
+config.ignore_caret = true
+config.ignore_displacements = false
+
+# Advanced features
+config.accessibility_validation = Applitools::AccessibilitySettings.new(
+  level: Applitools::AccessibilityLevel::AA,
+  guidelines_version: Applitools::AccessibilityGuidelinesVersion::WCAG_2_0
+)
+```
+
+The configuration system supports environment variables:
+- `APPLITOOLS_API_KEY` - Your API key
+- `APPLITOOLS_SERVER_URL` - The Applitools server URL
+- `APPLITOOLS_BRANCH` - Branch name for the test
+- `APPLITOOLS_PARENT_BRANCH` - Parent branch for baseline comparison
+- `APPLITOOLS_BASELINE_BRANCH` - Specific branch to use as baseline
+
+### Viewport Size
+
+The viewport size is defined using the `RectangleSize` class:
+
+```ruby
+viewport_size = Applitools::RectangleSize.new(width, height)
+```
+
+This class provides methods for manipulating and comparing sizes:
+
+```ruby
+size.width    # Get width
+size.height   # Get height
+size.empty?   # Check if width or height is zero
+size.to_hash  # Convert to a hash: {width: w, height: h}
+```
+
+### Batch Info
+
+The `BatchInfo` class groups test results for easier management:
+
+```ruby
+batch = Applitools::BatchInfo.new("My Batch Name")
+batch.id = "unique-batch-id"  # Optional, auto-generated if not provided
+batch.started_at = Time.now   # Optional, defaults to now
+```
+
+Batches with the same name and ID are grouped together in the Applitools dashboard.
+
+### Region
+
+The `Region` class represents a rectangular area for operations like:
+- Check specific parts of a page
+- Define ignore regions
+- Specify areas for accessibility checks
+
+```ruby
+region = Applitools::Region.new(left, top, width, height)
+
+# Operations
+region.contains?(location)   # Check if a point is inside the region
+region.intersect(other_region) # Get intersection of two regions
+region.empty?                # Check if the region has zero area
+```
+
+### Match Settings
+
+The `ImageMatchSettings` class controls how visual comparisons work:
+
+```ruby
+settings = Applitools::ImageMatchSettings.new
+settings.match_level = Applitools::MatchLevel::STRICT
+settings.ignore_caret = true
+settings.ignore_displacements = false
+```
+
+Match levels include:
+- `NONE` - No comparison (screenshot only)
+- `LAYOUT` - Compare layout structure
+- `CONTENT` - Compare textual content
+- `STRICT` - Compare visually with some tolerance (default)
+- `EXACT` - Pixel-perfect comparison
+
+## Universal SDK Integration
+
+The `eyes_core` gem integrates with the cross-language Universal SDK through several components:
+
+- `UniversalEyes` - Manages the session lifecycle and visual checks
+- `UniversalClient` - Handles communication with the Universal SDK
+- `UniversalCheckSettings` - Configures check operations
+- `UniversalServerControl` - Manages the Universal SDK process
+
+This integration provides:
+- Consistent behavior across language SDKs
+- Improved performance and reliability
+- Access to advanced features
+
+```ruby
+# The UniversalEyes class provides methods like:
+universal_eyes.check(check_settings, image_target)
+universal_eyes.close
+universal_eyes.abort
+```
+
+
+## Error Handling
+
+The SDK defines several error classes:
+
+- `EyesError` - Base class for all errors
+- `TestFailedError` - Test did not match the baseline
+- `DiffsFoundError` - Differences found during comparison
+- `NewTestError` - First run of a test with no baseline 
+
+```ruby
+begin
+  # Eyes operations
+  eyes.close
+rescue Applitools::NewTestError => e
+  puts "New test (no baseline): #{e.message}"
+  puts "See results at: #{e.test_results.url}"
+rescue Applitools::DiffsFoundError => e
+  puts "Found differences: #{e.message}"
+  puts "See results at: #{e.test_results.url}"
+rescue Applitools::TestFailedError => e
+  puts "Test failed: #{e.message}"
+rescue Applitools::EyesError => e
+  puts "Eyes error: #{e.message}"
+end
+```
+
+## Advanced Features
+
+### Accessibility Testing
+
+The SDK supports automated accessibility testing:
+
+```ruby
+# Configure accessibility testing
+config.accessibility_validation = Applitools::AccessibilitySettings.new(
+  level: Applitools::AccessibilityLevel::AA,
+  guidelines_version: Applitools::AccessibilityGuidelinesVersion::WCAG_2_1
+)
+
+# Add specific regions for accessibility checks
+check_settings.accessibility_region(
+  region, 
+  Applitools::AccessibilityRegionType::REGULAR_TEXT
+)
+```
+
+Accessibility levels:
+- `AA` - WCAG AA standard
+- `AAA` - WCAG AAA standard
+
+Guidelines versions:
+- `WCAG_2_0` - Web Content Accessibility Guidelines 2.0
+- `WCAG_2_1` - Web Content Accessibility Guidelines 2.1
+
+### Layout Breakpoints
+
+The SDK supports responsive design testing with layout breakpoints:
+
+```ruby
+# Enable automatic breakpoints
+config.layout_breakpoints = true
+
+# Specify exact breakpoint widths (in pixels)
+config.layout_breakpoints = [768, 1024, 1440]
+
+# Advanced configuration
+config.layout_breakpoints(
+  [768, 1024, 1440],  # Width breakpoints
+  reload: true,        # Reload page at each breakpoint
+  height_breakpoints: [600, 900]  # Height breakpoints
+)
+```
+
+### Proxy Configuration
+
+For environments that require a proxy to access the internet:
+
+```ruby
+# Basic proxy configuration
+config.proxy = Applitools::Connectivity::Proxy.new('http://proxy-address:port')
+
+# Proxy with authentication
+config.proxy = Applitools::Connectivity::Proxy.new(
+  'http://proxy-address:port',
+  'username',
+  'password'
+)
+
+# Alternative syntax
+config.set_proxy('http://proxy-address:port', 'username', 'password')
+```
+
+## Best Practices
+
+1. **Configuration Management**
+   - Create a base configuration that's shared across tests
+   - Override specific settings for individual tests as needed
+   - Use environment variables for deployment-specific settings
+
+2. **Batch Organization**
+   - Group related tests in the same batch
+   - Use descriptive batch names
+   - Consider using consistent batch IDs for CI/CD pipelines
+
+3. **Error Handling**
+   - Always wrap Eyes operations in try/catch blocks
+   - Handle different error types appropriately
+   - Decide on a strategy for handling new tests vs. failing tests
+
+4. **Resource Management**
+   - Always call `close` or `abort_if_not_closed` to release resources
+   - Use `abort_if_not_closed` in ensure blocks to prevent resource leaks
+
+5. **Performance Optimization**
+   - Only check what's necessary (specific regions when possible)
+   - Use the appropriate match level for each test
+   - Leverage batching to improve efficiency
+
+## Troubleshooting
+
+### Common Issues
+
+1. **API Key Errors**
+   - Ensure your API key is set correctly
+   - Check environment variables are properly configured
+   - Verify the API key has permissions for the server you're using
+
+2. **Connection Issues**
+   - Check network connectivity to Applitools servers
+   - Verify proxy settings if applicable
+   - Check server URL if using a private cloud
+
+3. **Match Level Problems**
+   - If getting too many false differences, consider using a less strict match level
+   - If missing important differences, use a stricter match level
+
+4. **Performance Issues**
+   - Large or complex pages may have slower performance
+   - Consider checking specific regions instead of full page
+   - Optimize match timeout settings
+
+
+### Logging
+
+The SDK provides built-in logging:
+
+```ruby
+# Set log level
+Applitools::EyesLogger.log_handler = Logger.new(STDOUT)
+Applitools::EyesLogger.log_handler.level = Logger::DEBUG
+```
+
+Log levels:
+- `DEBUG` - Very verbose for troubleshooting
+- `INFO` - Normal operations (default)
+- `WARN` - Potential issues
+- `ERROR` - Operation failures
+
+## FAQ
+
+### Q: Is `eyes_core` meant to be used directly?
+A: No, the `eyes_core` gem provides core functionality for other Eyes SDK implementations like `eyes_selenium` or `eyes_images`. You should use those specific implementations instead.
+
+### Q: How do I set my API key?
+A: You can set your API key in any of these ways:
+- Via environment variable: `ENV['APPLITOOLS_API_KEY']='your_api_key'`
+- In your code: `config.api_key = 'your_api_key'`
+- In your configuration file (if applicable to your test framework)
+
+### Q: How do match levels affect visual testing?
+A: Match levels determine how strictly Eyes compares screenshots:
+- `EXACT`: Pixel-perfect matching (very strict)
+- `STRICT`: Default level, allows small differences
+- `CONTENT`: More lenient, focuses on content matching
+- `LAYOUT`: Most lenient, only checks layout structure
+
+### Q: What's the difference between `close` and `abort_if_not_closed`?
+A: `close` completes the test and reports results to the Applitools dashboard, while `abort_if_not_closed` terminates the test without reporting results. Use `abort_if_not_closed` in exception handling.
+
+### Q: How do I handle tests with no baseline?
+A: When running a test for the first time with no baseline, it will raise a `NewTestError`. You can:
+1. Catch this error and handle it (e.g., approve it automatically in certain environments)
+2. Pass `false` to the `throw_exception` parameter of `close` to prevent the exception
+3. Use `save_new_tests = true` in your configuration (default) to save new tests as baselines
+
+
+### Q: Can I use eyes_core with non-web applications?
+A: Yes, through specialized SDKs like `eyes_images` for image comparison or `eyes_appium` for mobile testing, which build on the core functionality provided by `eyes_core`.
+
+## License
+
+This SDK is distributed under the Applitools SDK License Agreement. See the [LICENSE](LICENSE) file for more details.
+
+**Important:** This SDK may be used solely for your personal, non-commercial purposes. For commercial use, please contact your Applitools representative or visit [applitools.com](https://applitools.com) to obtain a commercial license.

data/eyes_core.gemspec

@@ -14,11 +14,13 @@ Gem::Specification.new do |spec|
   spec.description   = "Don't use it directly, take a look at eyes_selenium, eyes_images or eyes_calabash gems instead."
   spec.summary       = 'Core of the Applitools Ruby SDK'
   spec.homepage      = 'https://www.applitools.com'
-  spec.license       = 'Applitools'
+  spec.license       = 'Proprietary'
 
   spec.files         = `git ls-files lib/applitools`.split($RS) + [
     'lib/require_utils.rb',
     'lib/eyes_core.rb',
+    'LICENSE',
+    'README.md',
     'CHANGELOG.md',
     'eyes_core.gemspec',
     'Rakefile',
@@ -38,13 +40,12 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'colorize'
   spec.add_dependency 'websocket'
   spec.add_dependency 'sorted_set'
-  spec.add_dependency 'eyes_universal', "= 4.38.0"
+  spec.add_dependency 'eyes_universal', "= 4.40.0"
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '>= 3'
   spec.add_development_dependency 'rubocop', '<= 0.46.0'
-  spec.add_development_dependency 'webdrivers', '~> 5.0'
 
   # Exclude debugging support on Travis CI, due to its incompatibility with jruby and older rubies.
   unless ENV['TRAVIS']

data/lib/applitools/core/app_output_with_screenshot.rb

@@ -7,8 +7,7 @@ module Applitools
     def initialize(app_output, screenshot, allow_empty_screenshot = false)
       raise Applitools::EyesIllegalArgument.new 'app_output is not kind of Applitools::AppOutput' unless
           app_output.is_a? Applitools::AppOutput
-      raise Applitools::EyesIllegalArgument.new 'screenshot is not kind of Applitools::EyesScreenshot' unless
-          allow_empty_screenshot || screenshot.is_a?(Applitools::EyesScreenshot)
+      # No type checking for screenshot since EyesScreenshot is removed
       @app_output = app_output
       @screenshot = screenshot
     end
@@ -25,4 +24,4 @@ module Applitools
       app_output.screenshot_url
     end
   end
-end
+end

data/lib/applitools/core/debug_screenshot_provider.rb

@@ -15,7 +15,9 @@ module Applitools
       case image
       when Applitools::Screenshot
         image.save(file_name_to_save(suffix)) if image.area > 0
-      when Applitools::EyesScreenshot
+      # EyesScreenshot class has been removed
+      # when responding to :image method, try to save the image
+      when -> (img) { img.respond_to?(:image) && img.image.respond_to?(:area) && img.image.respond_to?(:save) }
         image.image.save(file_name_to_save(suffix)) if image.image.area > 0
       # when String
       #   ::ChunkyPNG::Image.from_string(image).save(file_name_to_save(suffix))

data/lib/applitools/core/eyes_base.rb

@@ -38,8 +38,9 @@ module Applitools
 
     USE_DEFAULT_TIMEOUT = -1
 
-    SCREENSHOT_AS_IS = Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is].freeze
-    CONTEXT_RELATIVE = Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative].freeze
+    # Define these constants directly since EyesScreenshot is removed
+    SCREENSHOT_AS_IS = :screenshot_as_is
+    CONTEXT_RELATIVE = :context_relative
 
     class << self
       def set_viewport_size(driver, viewport_size)
@@ -677,8 +678,8 @@ module Applitools
         return
       end
 
-      control = last_screenshot.intersected_region control, EyesScreenshot::COORDINATE_TYPES[:context_relative],
-        EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+      # Use constants defined at class level since EyesScreenshot is removed
+      control = last_screenshot.intersected_region control, CONTEXT_RELATIVE, SCREENSHOT_AS_IS
 
       if control.empty?
         logger.info "Ignoring '#{text}' out of bounds"

data/lib/applitools/core/eyes_screenshot.rb

@@ -1,62 +1,14 @@
 # frozen_string_literal: true
 
+# Empty placeholder for backward compatibility
+# This class has been removed as its functionality is now handled by the Universal SDK
+
 module Applitools
+  # Empty placeholder class to maintain backward compatibility
   class EyesScreenshot
-    extend Forwardable
-    extend Applitools::Helpers
-
-    def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
-    attr_accessor :image, :top_left_location
-    def_delegators '@image', :width, :height
-
     COORDINATE_TYPES = {
-      context_as_is: 'CONTEXT_AS_IS',
-      screenshot_as_is: 'SCREENSHOT_AS_IS',
-      context_relative: 'CONTEXT_RELATIVE'
+      context_relative: :context_relative,
+      screenshot_as_is: :screenshot_as_is
     }.freeze
-
-    def initialize(screenshot)
-      Applitools::ArgumentGuard.is_a? screenshot, 'screenshot', Applitools::Screenshot
-      self.image = screenshot
-    end
-
-    abstract_method :sub_screenshot, false
-    abstract_method :convert_location, false
-    abstract_method :location_in_screenshot, false
-    abstract_method :intersected_region, false
-
-    def sub_screenshots(regions, coordinate_type)
-      Applitools::ArgumentGuard.is_a? regions, 'regions', Enumerable
-      regions.map do |region|
-        sub_screenshot(region, coordinate_type, false, true)
-      end
-    end
-
-    def convert_region_location(region, from, to)
-      Applitools::ArgumentGuard.not_nil region, 'region'
-      Applitools::ArgumentGuard.is_a? region, 'region', Applitools::Region
-      if region.empty?
-        return region.dup.tap do |r|
-          r.left = 0
-          r.top = 0
-          r.width = 0
-          r.height = 0
-        end
-      end
-      Applitools::ArgumentGuard.not_nil from, 'from'
-      Applitools::ArgumentGuard.not_nil to, 'to'
-
-      updated_location = convert_location(region.location, from, to)
-      region.dup.tap do |r|
-        r.left = updated_location.x
-        r.top = updated_location.y
-      end
-    end
-
-    private
-
-    def image_region
-      Applitools::Region.new(0, 0, image.width, image.height)
-    end
   end
-end
+end

data/lib/applitools/core/image_match_settings.rb

@@ -94,20 +94,22 @@ module Applitools
       end
 
       def ==(other)
-        min_diff_intensity == other.min_diff_intensity &&
-          min_diff_width == other.min_diff_width &&
-          min_diff_height == other.min_diff_height &&
-          match_threshold == other.match_threshold
+        return false unless other.is_a?(self.class)
+        self.min_diff_intensity == other.min_diff_intensity &&
+          self.min_diff_width == other.min_diff_width &&
+          self.min_diff_height == other.min_diff_height &&
+          self.match_threshold == other.match_threshold
       end
 
       def to_hash
         {
-          minDiffIntensity: min_diff_intensity,
-          minDiffWidth: min_diff_width,
-          minDiffHeight: min_diff_height,
-          matchThreshold: match_threshold
+          minDiffIntensity: self.min_diff_intensity,
+          minDiffWidth: self.min_diff_width,
+          minDiffHeight: self.min_diff_height,
+          matchThreshold: self.match_threshold
         }
       end
+
     end
 
     # export type MatchSettings<TRegion> = {

data/lib/applitools/core/match_level_setter.rb

@@ -5,17 +5,18 @@ module Applitools::MatchLevelSetter
     raise Applitools::EyesError unless
         Applitools::MATCH_LEVEL.keys.include?(value) | Applitools::MatchLevel.enum_values.include?(value)
 
-    if value != :exact && value != Applitools::MatchLevel::EXACT && (exact_options && !exact_options.empty?)
-      raise Applitools::EyesError.new(
-        'Exact options are accepted only for EXACT match level'
-      )
-    end
     match_level_value = if Applitools::MatchLevel.enum_values.include?(value)
                           value
                         else
                           Applitools::MATCH_LEVEL[value]
                         end
-    [match_level_value, value == Applitools::MatchLevel::EXACT ? convert_exact_options(exact_options) : nil]
+    if match_level_value != Applitools::MatchLevel::EXACT && (exact_options && !exact_options.empty?)
+      raise Applitools::EyesError.new(
+        'Exact options are accepted only for EXACT match level'
+      )
+    end
+
+    [match_level_value, match_level_value == Applitools::MatchLevel::EXACT ? convert_exact_options(exact_options) : nil]
   end
 
   private

data/lib/applitools/core/match_window_data.rb

@@ -7,8 +7,9 @@ module Applitools
         return region.with_padding.to_hash if region.respond_to?(:converted?) && region.converted?
         screenshot.convert_region_location(
           region.with_padding,
-          Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative],
-          Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+          # Use constants directly since EyesScreenshot is removed
+          :context_relative,
+          :screenshot_as_is
         ).to_hash
       end
 
@@ -387,8 +388,9 @@ module Applitools
         self.floating_regions = @floating_regions.map do |r|
           updated_region = app_output.screenshot.convert_region_location(
             r,
-            Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative],
-            Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+            # Use constants directly since EyesScreenshot is removed
+            :context_relative,
+            :screenshot_as_is
           )
 
           Applitools::FloatingRegion.new(

data/lib/applitools/core/universal_eyes_open.rb

@@ -3,7 +3,7 @@
 module Applitools
   module UniversalEyesOpen
 
-    # Starts a test
+    # Starts a test with Universal SDK
     #
     # @param options [Hash] options
     # @option options :driver The driver that controls the browser hosting the application
@@ -14,8 +14,8 @@ module Applitools
     #   (i.e., the visible part of the document's body) or +nil+ to use the current window's viewport.
     # @option options :session_type The type of the test (e.g., standard test / visual performance test).
     #   Default value is 'SEQUENTAL'
-    # @return [Applitools::Selenium::Driver] A wrapped web driver which enables Eyes
-    #   trigger recording and frame handling
+    # @return [Applitools::Selenium::Driver] A wrapped web driver for internal SDK use
+    #   (Note: open() method will return the original, unwrapped driver)
     def universal_open(options = {})
       original_driver = options.delete(:driver)
       if self.class.name != 'Applitools::Images::Eyes'
@@ -27,10 +27,18 @@ module Applitools
         end
 
         self.driver = Applitools::Selenium::SeleniumEyes.eyes_driver(original_driver, self)
+        
+        # Call driver-specific settings if available
+        if respond_to?(:perform_driver_specific_settings, true)
+          perform_driver_specific_settings(original_driver)
+        end
       end
 
       update_config_from_options(options)
       universal_driver_config = driver.universal_driver_config if self.class.name != 'Applitools::Images::Eyes'
+      
+      # Ensure we have a runner (default to ClassicRunner if not provided)
+      self.runner ||= Applitools::ClassicRunner.new
       universal_eyes_manager = runner.get_universal_eyes_manager(self)
 
       universal_eyes_config = Applitools::UniversalEyesConfig.new

data/lib/applitools/core/universal_new_api.rb

@@ -12,15 +12,31 @@ module Applitools
     def extract_text(*args)
       image_target = args[0].is_a?(Hash) ? args[0] : nil
       targets_array = args[0].is_a?(Hash) ? args[1].to_a : args[0]
-      targets_array.map do |target|
-        target['target'] = { elementId: target['target'].ref } if target['target'].is_a?(::Selenium::WebDriver::Element)
-        target['target']['x'] = target['target'].delete('left') if target['target']['left']
-        target['target']['y'] = target['target'].delete('top') if target['target']['top']
+      targets_array = targets_array.map do |target|
+        # Handle element references
+        if target['target'].is_a?(::Selenium::WebDriver::Element)
+          ref = target['target'].ref
+          # Handle different formats of element refs
+          ref = ref[1] if ref.is_a?(Array) && ref[0] == :element
+          target['target'] = { elementId: ref }
+        elsif target['target'].is_a?(String)
+          # It's a CSS selector
+          target['target'] = target['target']
+        elsif target['target'].is_a?(Hash)
+          # Handle coordinate-based regions
+          if target['target']['left']
+            target['target']['x'] = target['target'].delete('left')
+          end
+          if target['target']['top']
+            target['target']['y'] = target['target'].delete('top')
+          end
+        end
         target[:region] = target.delete('target')
         target
       end
-      driver_target = respond_to?(:driver) ? driver.universal_driver_config : image_target
-      universal_eyes.extract_text(targets_array, driver_target)
+      driver_target = respond_to?(:driver) ? Applitools::Selenium.universal_driver_config(driver) : image_target
+      result = universal_eyes.extract_text(targets_array, driver_target)
+      result
     end
 
 
@@ -31,7 +47,7 @@ module Applitools
     #   language?: string
     # }
     def extract_text_regions(patterns_array)
-      driver_target = respond_to?(:driver) ? driver.universal_driver_config : { image: patterns_array.delete('image') }
+      driver_target = respond_to?(:driver) ? Applitools::Selenium.universal_driver_config(driver) : { image: patterns_array.delete('image') }
       results = universal_eyes.extract_text_regions(patterns_array, driver_target)
       Applitools::Utils.deep_stringify_keys(results)
     end
@@ -42,7 +58,7 @@ module Applitools
         locatorNames: locate_settings[:locator_names],
         firstOnly: !!locate_settings[:first_only]
       }
-      driver_target = locate_settings.has_key?(:image) ? {image: locate_settings[:image]} : driver.universal_driver_config
+      driver_target = locate_settings.has_key?(:image) ? {image: locate_settings[:image]} : Applitools::Selenium.universal_driver_config(driver)
       results = universal_eyes.locate(settings, driver_target)
 
       old_style = results.map do |k, v|

data/lib/applitools/eyes_core/version.rb

@@ -2,7 +2,7 @@
 
 module Applitools
   module EyesCore
-    VERSION = '6.7.1'.freeze
+    VERSION = '6.7.2'.freeze
   end
 
   VERSION = Applitools::EyesCore::VERSION

data/lib/applitools/universal_sdk/universal_client.rb

@@ -255,7 +255,9 @@ module Applitools::Connectivity
       # type ExtractTextResponsePayload = string[]
       payload = { target: driver_target, settings: regions, config: commands_config }
       payload.delete(:settings) if regions.empty?
-      command_with_result(EYES_EXTRACT_TEXT, payload)
+      result = command_with_result(EYES_EXTRACT_TEXT, payload)
+      # Ensure we return the result array
+      result.is_a?(Hash) && result['result'] ? result['result'] : result
     end
 
     def eyes_close(eyes)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_core
 version: !ruby/object:Gem::Version
-  version: 6.7.1
+  version: 6.7.2
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-05-22 00:00:00.000000000 Z
+date: 2025-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.38.0
+        version: 4.40.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.38.0
+        version: 4.40.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -178,20 +178,6 @@ dependencies:
     - - "<="
       - !ruby/object:Gem::Version
         version: 0.46.0
-- !ruby/object:Gem::Dependency
-  name: webdrivers
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -285,6 +271,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- LICENSE
+- README.md
 - Rakefile
 - eyes_core.gemspec
 - lib/applitools/connectivity/proxy.rb
@@ -369,7 +357,7 @@ files:
 - lib/require_utils.rb
 homepage: https://www.applitools.com
 licenses:
-- Applitools
+- Proprietary
 metadata:
   yard.run: yri
 post_install_message: