playwright-ruby-client 1.51.0 → 1.52.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f0c4c8f2c68d03a9009e450794670263e74a7bff0f94307ac38222ac402b06b
-  data.tar.gz: a21fee77abeef39269d2d84b511a37ac3df6a6f9bb0b3e881be20bd4fb055073
+  metadata.gz: 6bcda43c43e75e840a897607afdc89d2b01cd463b937944ad33522d7a36713a1
+  data.tar.gz: f92d747e11ef4c55cc9769bc053194a18c2183d13862fe1c7bbb641a6ab6cbfd
 SHA512:
-  metadata.gz: c744d68230d2f37b6ce1894d55156ecfc943739c8d713332098ed73eb2c12533fab814685eaf3efdabd5561227c1deef042aad50e22e98b91e3be2e61f9974a2
-  data.tar.gz: 8b1e2a83b1eac587c1df0963c586a64361191384018175972bf40eab3dcdb86d9b01a3d202f9d24e6b611f250ca8ead38f112252970ed0f292e4bd2fa5b5f27e
+  metadata.gz: 246d118dcb834c6d6a266286c1b2758d57e1480f8c40ffec06e2d08401f1e0b87934a8d1701c400053a5a226a81c22a2a4994ce3615a21e46d8ec689cd1289a2
+  data.tar.gz: 1537e5f55e68ff8c11c5d23a1dd1cb973e6aa3df9f8d528e6e93ecc4c744b663a75b8e0cafd38650b39d50d33cd930c3b1c87ebd889ef0cdb7a1481a7ee1c0c2

data/documentation/docs/api/locator.md

@@ -87,7 +87,7 @@ button = page.get_by_role("button").and(page.get_by_title("Subscribe"))
 ## aria_snapshot
 
 ```
-def aria_snapshot(timeout: nil)
+def aria_snapshot(ref: nil, timeout: nil)
 ```
 
 

data/documentation/docs/api/locator_assertions.md

@@ -116,6 +116,15 @@ expect(locator).not_to be_visible(timeout: nil, visible: nil)
 
 The opposite of [LocatorAssertions#to_be_visible](./locator_assertions#to_be_visible).
 
+## not_to_contain_class
+
+```ruby
+expect(locator).not_to contain_class(expected, timeout: nil)
+```
+
+
+The opposite of [LocatorAssertions#to_contain_class](./locator_assertions#to_contain_class).
+
 ## not_to_contain_text
 
 ```ruby
@@ -436,6 +445,43 @@ expect(
 ).to be_visible
 ```
 
+## to_contain_class
+
+```ruby
+expect(locator).to contain_class(expected, timeout: nil)
+```
+
+
+Ensures the [Locator](./locator) points to an element with given CSS classes. All classes from the asserted value, separated by spaces, must be present in the [Element.classList](https://developer.mozilla.org/en-US/docs/Web/API/Element/classList) in any order.
+
+**Usage**
+
+```html
+<div class='middle selected row' id='component'></div>
+```
+
+```ruby
+locator = page.locator("#component")
+expect(locator).to contain_class("middle selected row")
+expect(locator).to contain_class("selected")
+expect(locator).to contain_class("row middle")
+```
+
+When an array is passed, the method asserts that the list of elements located matches the corresponding list of expected class lists. Each element's class attribute is matched against the corresponding class in the array:
+
+```html
+<div class='list'></div>
+  <div class='component inactive'></div>
+  <div class='component active'></div>
+  <div class='component inactive'></div>
+</div>
+```
+
+```ruby
+locator = page.locator(".list > .component")
+expect(locator).to contain_class(["inactive", "active", "inactive"])
+```
+
 ## to_contain_text
 
 ```ruby
@@ -561,7 +607,7 @@ expect(locator).to have_class(expected, timeout: nil)
 ```
 
 
-Ensures the [Locator](./locator) points to an element with given CSS classes. When a string is provided, it must fully match the element's `class` attribute. To match individual classes or perform partial matches, use a regular expression:
+Ensures the [Locator](./locator) points to an element with given CSS classes. When a string is provided, it must fully match the element's `class` attribute. To match individual classes use [LocatorAssertions#to_contain_class](./locator_assertions#to_contain_class).
 
 **Usage**
 
@@ -569,10 +615,13 @@ Ensures the [Locator](./locator) points to an element with given CSS classes. Wh
 <div class='middle selected row' id='component'></div>
 ```
 
-```ruby
+```python title="example_a596f37c41d76277b59ed7eb46969c178c89770d0da91bdff20f36d438aa32cd.py"
+from playwright.sync_api import expect
+
 locator = page.locator("#component")
-expect(locator).to have_class(/(^|\s)selected(\s|$)/)
-expect(locator).to have_class("middle selected row")
+expect(locator).to_have_class("middle selected row")
+expect(locator).to_have_class(re.compile(r"(^|\\s)selected(\\s|$)"))
+
 ```
 
 When an array is passed, the method asserts that the list of elements located matches the corresponding list of expected class values. Each element's class attribute is matched against the corresponding string or regular expression in the array:

data/documentation/docs/api/route.md

@@ -49,6 +49,8 @@ The `headers` option applies to both the routed request and any redirects it ini
 
 [Route#continue](./route#continue) will immediately send the request to the network, other matching handlers won't be invoked. Use [Route#fallback](./route#fallback) If you want next matching handler in the chain to be invoked.
 
+**NOTE**: The `Cookie` header cannot be overridden using this method. If a value is provided, it will be ignored, and the cookie will be loaded from the browser's cookie store. To set custom cookies, use [BrowserContext#add_cookies](./browser_context#add_cookies).
+
 ## fallback
 
 ```

data/documentation/docs/include/api_coverage.md

@@ -563,6 +563,7 @@
 * not_to_be_hidden
 * not_to_be_in_viewport
 * not_to_be_visible
+* not_to_contain_class
 * not_to_contain_text
 * not_to_have_accessible_description
 * not_to_have_accessible_error_message
@@ -588,6 +589,7 @@
 * to_be_hidden
 * to_be_in_viewport
 * to_be_visible
+* to_contain_class
 * to_contain_text
 * to_have_accessible_description
 * to_have_accessible_error_message

data/lib/playwright/javascript/value_parser.rb

@@ -1,4 +1,5 @@
-require 'date'
+require 'base64'
+require 'time'
 
 module Playwright
   module JavaScript
@@ -45,7 +46,7 @@ module Playwright
         end
 
         if hash.key?('d')
-          return DateTime.parse(hash['d'])
+          return Time.parse(hash['d'])
         end
 
         if hash.key?('u')
@@ -105,6 +106,57 @@ module Playwright
           return @handles[hash['h']]
         end
 
+        if hash.key?('ta')
+          encoded_bytes = hash['ta']['b']
+          decoded_bytes = Base64.strict_decode64(encoded_bytes)
+          array_type = hash['ta']['k']
+
+          if array_type == 'i8'
+            word_size = 1
+            unpack_format = 'c*' # signed char
+          elsif array_type == 'ui8' || array_type == 'ui8c'
+            word_size = 1
+            unpack_format = 'C*' # unsigned char
+          elsif array_type == 'i16'
+            word_size = 2
+            unpack_format = 's<*' # signed short, little-endian
+          elsif array_type == 'ui16'
+            word_size = 2
+            unpack_format = 'S<*' # unsigned short, little-endian
+          elsif array_type == 'i32'
+            word_size = 4
+            unpack_format = 'l<*' # signed long, little-endian
+          elsif array_type == 'ui32'
+            word_size = 4
+            unpack_format = 'L<*' # unsigned long, little-endian
+          elsif array_type == 'f32'
+            word_size = 4
+            unpack_format = 'e*' # float, little-endian
+          elsif array_type == 'f64'
+            word_size = 8
+            unpack_format = 'E*' # double, little-endian
+          elsif array_type == 'bi64'
+            word_size = 8
+            unpack_format = 'q<*' # signed long long, little-endian
+          elsif array_type == 'bui64'
+            word_size = 8
+            unpack_format = 'Q<*' # unsigned long long, little-endian
+          else
+            raise ArgumentError, "Unsupported array type: #{array_type}"
+          end
+
+          byte_len = decoded_bytes.bytesize
+          if byte_len.zero?
+            return []
+          end
+
+          if byte_len % word_size != 0
+            raise ArgumentError, "Decoded bytes length #{byte_len} is not a multiple of word size #{word_size} for type #{array_type}"
+          end
+
+          return decoded_bytes.unpack(unpack_format)
+        end
+
         raise ArgumentError.new("Unexpected value: #{hash}")
       end
     end

data/lib/playwright/locator_assertions_impl.rb

@@ -232,6 +232,39 @@ module Playwright
     end
     _define_negation :to_have_class
 
+    def to_contain_class(expected, timeout: nil)
+      if expected.is_a?(Enumerable)
+        if expected.any? { |e| e.is_a?(Regexp) }
+          raise ArgumentError.new('"expected" argument in toContainClass cannot contain RegExp values')
+        end
+        expected_text = to_expected_text_values(expected)
+        expect_impl(
+          "to.contain.class.array",
+          {
+            expectedText: expected_text,
+            timeout: timeout,
+          },
+          expected,
+          "Locator expected to contain class names"
+        )
+      else # Single string
+        if expected.is_a?(Regexp)
+          raise ArgumentError.new('"expected" argument in toContainClass cannot be a RegExp value')
+        end
+        expected_text = to_expected_text_values([expected])
+        expect_impl(
+          "to.contain.class",
+          {
+            expectedText: expected_text,
+            timeout: timeout,
+          },
+          expected,
+          "Locator expected to contain class"
+        )
+      end
+    end
+    _define_negation :to_contain_class
+
     def to_have_count(count, timeout: nil)
       expect_impl(
         "to.have.count",

data/lib/playwright/locator_impl.rb

@@ -397,10 +397,11 @@ module Playwright
       end
     end
 
-    def aria_snapshot(timeout: nil)
+    def aria_snapshot(timeout: nil, ref: nil)
       @frame.channel.send_message_to_server('ariaSnapshot', {
         selector: @selector,
         timeout: timeout,
+        ref: ref,
       }.compact)
     end
 

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.51.0'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.51.0'
+  VERSION = '1.52.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.52.0'
 end

data/lib/playwright_api/api_request.rb

@@ -15,6 +15,7 @@ module Playwright
           failOnStatusCode: nil,
           httpCredentials: nil,
           ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
           proxy: nil,
           storageState: nil,
           timeout: nil,

data/lib/playwright_api/browser_context.rb

@@ -463,16 +463,6 @@ module Playwright
       raise NotImplementedError.new('wait_for_event is not implemented yet.')
     end
 
-    # @nodoc
-    def owner_page=(req)
-      wrap_impl(@impl.owner_page=(unwrap_impl(req)))
-    end
-
-    # @nodoc
-    def options=(req)
-      wrap_impl(@impl.options=(unwrap_impl(req)))
-    end
-
     # @nodoc
     def enable_debug_console!
       wrap_impl(@impl.enable_debug_console!)
@@ -488,6 +478,16 @@ module Playwright
       wrap_impl(@impl.browser=(unwrap_impl(req)))
     end
 
+    # @nodoc
+    def options=(req)
+      wrap_impl(@impl.options=(unwrap_impl(req)))
+    end
+
+    # @nodoc
+    def owner_page=(req)
+      wrap_impl(@impl.owner_page=(unwrap_impl(req)))
+    end
+
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)

data/lib/playwright_api/locator.rb

@@ -103,8 +103,8 @@ module Playwright
     #   - listitem:
     #     - link "About"
     # ```
-    def aria_snapshot(timeout: nil)
-      wrap_impl(@impl.aria_snapshot(timeout: unwrap_impl(timeout)))
+    def aria_snapshot(ref: nil, timeout: nil)
+      wrap_impl(@impl.aria_snapshot(ref: unwrap_impl(ref), timeout: unwrap_impl(timeout)))
     end
 
     #

data/lib/playwright_api/locator_assertions.rb

@@ -72,6 +72,12 @@ module Playwright
       wrap_impl(@impl.not_to_be_visible(timeout: unwrap_impl(timeout), visible: unwrap_impl(visible)))
     end
 
+    #
+    # The opposite of [`method: LocatorAssertions.toContainClass`].
+    def not_to_contain_class(expected, timeout: nil)
+      wrap_impl(@impl.not_to_contain_class(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
+    end
+
     #
     # The opposite of [`method: LocatorAssertions.toContainText`].
     def not_to_contain_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil)
@@ -328,6 +334,44 @@ module Playwright
       wrap_impl(@impl.to_be_visible(timeout: unwrap_impl(timeout), visible: unwrap_impl(visible)))
     end
 
+    #
+    # Ensures the `Locator` points to an element with given CSS classes. All classes from the asserted value, separated by spaces, must be present in the [Element.classList](https://developer.mozilla.org/en-US/docs/Web/API/Element/classList) in any order.
+    #
+    # **Usage**
+    #
+    # ```html
+    # <div class='middle selected row' id='component'></div>
+    # ```
+    #
+    # ```python sync
+    # from playwright.sync_api import expect
+    #
+    # locator = page.locator("#component")
+    # expect(locator).to_contain_class("middle selected row")
+    # expect(locator).to_contain_class("selected")
+    # expect(locator).to_contain_class("row middle")
+    # ```
+    #
+    # When an array is passed, the method asserts that the list of elements located matches the corresponding list of expected class lists. Each element's class attribute is matched against the corresponding class in the array:
+    #
+    # ```html
+    # <div class='list'></div>
+    #   <div class='component inactive'></div>
+    #   <div class='component active'></div>
+    #   <div class='component inactive'></div>
+    # </div>
+    # ```
+    #
+    # ```python sync
+    # from playwright.sync_api import expect
+    #
+    # locator = page.locator("list > .component")
+    # await expect(locator).to_contain_class(["inactive", "active", "inactive"])
+    # ```
+    def to_contain_class(expected, timeout: nil)
+      wrap_impl(@impl.to_contain_class(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
+    end
+
     #
     # Ensures the `Locator` points to an element that contains the given text. All nested elements will be considered when computing the text content of the element. You can use regular expressions for the value as well.
     #
@@ -439,7 +483,7 @@ module Playwright
     end
 
     #
-    # Ensures the `Locator` points to an element with given CSS classes. When a string is provided, it must fully match the element's `class` attribute. To match individual classes or perform partial matches, use a regular expression:
+    # Ensures the `Locator` points to an element with given CSS classes. When a string is provided, it must fully match the element's `class` attribute. To match individual classes use [`method: LocatorAssertions.toContainClass`].
     #
     # **Usage**
     #
@@ -451,8 +495,8 @@ module Playwright
     # from playwright.sync_api import expect
     #
     # locator = page.locator("#component")
-    # expect(locator).to_have_class(re.compile(r"(^|\\s)selected(\\s|$)"))
     # expect(locator).to_have_class("middle selected row")
+    # expect(locator).to_have_class(re.compile(r"(^|\\s)selected(\\s|$)"))
     # ```
     #
     # When an array is passed, the method asserts that the list of elements located matches the corresponding list of expected class values. Each element's class attribute is matched against the corresponding string or regular expression in the array:

data/lib/playwright_api/page.rb

@@ -1792,16 +1792,6 @@ module Playwright
       raise NotImplementedError.new('wait_for_event is not implemented yet.')
     end
 
-    # @nodoc
-    def owned_context=(req)
-      wrap_impl(@impl.owned_context=(unwrap_impl(req)))
-    end
-
-    # @nodoc
-    def guid
-      wrap_impl(@impl.guid)
-    end
-
     # @nodoc
     def start_js_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)
       wrap_impl(@impl.start_js_coverage(resetOnNavigation: unwrap_impl(resetOnNavigation), reportAnonymousScripts: unwrap_impl(reportAnonymousScripts)))
@@ -1822,6 +1812,16 @@ module Playwright
       wrap_impl(@impl.stop_css_coverage)
     end
 
+    # @nodoc
+    def owned_context=(req)
+      wrap_impl(@impl.owned_context=(unwrap_impl(req)))
+    end
+
+    # @nodoc
+    def guid
+      wrap_impl(@impl.guid)
+    end
+
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)

data/lib/playwright_api/request.rb

@@ -196,13 +196,13 @@ module Playwright
     end
 
     # @nodoc
-    def apply_fallback_overrides(overrides)
-      wrap_impl(@impl.apply_fallback_overrides(unwrap_impl(overrides)))
+    def header_values(name)
+      wrap_impl(@impl.header_values(unwrap_impl(name)))
     end
 
     # @nodoc
-    def header_values(name)
-      wrap_impl(@impl.header_values(unwrap_impl(name)))
+    def apply_fallback_overrides(overrides)
+      wrap_impl(@impl.apply_fallback_overrides(unwrap_impl(overrides)))
     end
 
     # -- inherited from EventEmitter --

data/lib/playwright_api/route.rb

@@ -35,6 +35,8 @@ module Playwright
     # The `headers` option applies to both the routed request and any redirects it initiates. However, `url`, `method`, and `postData` only apply to the original request and are not carried over to redirected requests.
     #
     # [`method: Route.continue`] will immediately send the request to the network, other matching handlers won't be invoked. Use [`method: Route.fallback`] If you want next matching handler in the chain to be invoked.
+    #
+    # **NOTE**: The `Cookie` header cannot be overridden using this method. If a value is provided, it will be ignored, and the cookie will be loaded from the browser's cookie store. To set custom cookies, use [`method: BrowserContext.addCookies`].
     def continue(headers: nil, method: nil, postData: nil, url: nil)
       wrap_impl(@impl.continue(headers: unwrap_impl(headers), method: unwrap_impl(method), postData: unwrap_impl(postData), url: unwrap_impl(url)))
     end

data/lib/playwright_api/worker.rb

@@ -47,13 +47,13 @@ module Playwright
     end
 
     # @nodoc
-    def page=(req)
-      wrap_impl(@impl.page=(unwrap_impl(req)))
+    def context=(req)
+      wrap_impl(@impl.context=(unwrap_impl(req)))
     end
 
     # @nodoc
-    def context=(req)
-      wrap_impl(@impl.context=(unwrap_impl(req)))
+    def page=(req)
+      wrap_impl(@impl.page=(unwrap_impl(req)))
     end
 
     # -- inherited from EventEmitter --

data/sig/playwright.rbs

@@ -456,7 +456,7 @@ module Playwright
     def all_inner_texts: -> Array[untyped]
     def all_text_contents: -> Array[untyped]
     def and: (Locator locator) -> Locator
-    def aria_snapshot: (?timeout: Float) -> String
+    def aria_snapshot: (?ref: bool, ?timeout: Float) -> String
     def blur: (?timeout: Float) -> void
     def bounding_box: (?timeout: Float) -> (nil | Hash[untyped, untyped])
     def check: (?force: bool, ?noWaitAfter: bool, ?position: Hash[untyped, untyped], ?timeout: Float, ?trial: bool) -> void
@@ -570,6 +570,7 @@ module Playwright
     def not_to_be_hidden: (?timeout: Float) -> void
     def not_to_be_in_viewport: (?ratio: Float, ?timeout: Float) -> void
     def not_to_be_visible: (?timeout: Float, ?visible: bool) -> void
+    def not_to_contain_class: ((String | Array[untyped]) expected, ?timeout: Float) -> void
     def not_to_contain_text: ((String | Regexp | Array[untyped] | Array[untyped] | Array[untyped]) expected, ?ignoreCase: bool, ?timeout: Float, ?useInnerText: bool) -> void
     def not_to_have_accessible_description: ((String | Regexp) name, ?ignoreCase: bool, ?timeout: Float) -> void
     def not_to_have_accessible_error_message: ((String | Regexp) errorMessage, ?ignoreCase: bool, ?timeout: Float) -> void
@@ -595,6 +596,7 @@ module Playwright
     def to_be_hidden: (?timeout: Float) -> void
     def to_be_in_viewport: (?ratio: Float, ?timeout: Float) -> void
     def to_be_visible: (?timeout: Float, ?visible: bool) -> void
+    def to_contain_class: ((String | Array[untyped]) expected, ?timeout: Float) -> void
     def to_contain_text: ((String | Regexp | Array[untyped] | Array[untyped] | Array[untyped]) expected, ?ignoreCase: bool, ?timeout: Float, ?useInnerText: bool) -> void
     def to_have_accessible_description: ((String | Regexp) description, ?ignoreCase: bool, ?timeout: Float) -> void
     def to_have_accessible_error_message: ((String | Regexp) errorMessage, ?ignoreCase: bool, ?timeout: Float) -> void

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: playwright-ruby-client
 version: !ruby/object:Gem::Version
-  version: 1.51.0
+  version: 1.52.0
 platform: ruby
 authors:
 - YusukeIwaki
 bindir: exe
 cert_chain: []
-date: 2025-03-17 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -407,7 +407,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
-summary: The Ruby binding of playwright driver 1.51.0
+summary: The Ruby binding of playwright driver 1.52.0
 test_files: []