chromate-rb 0.0.2.pre → 0.0.3.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d230805cd031a51b1d63131bf6dfba4692d46e7d1d8789a949c4767e461911e
-  data.tar.gz: 408a79332c2fdd4d96b28e53b149bbda859bcc1e621186a7911a3264d1673363
+  metadata.gz: 69be8ab00b56202a699439b91f9578f662570c4686fd290aa2c151d0f843b18d
+  data.tar.gz: 9513eee5138f694a31d628f0fbb63ced5c750c4e9213967c27a9cacddc04f799
 SHA512:
-  metadata.gz: cfe50cf45e2261fe0bcc7c03a0b66aa91f54c787a7688133b4722dde1bc22f86bcc0379b3b396efc2ea3c8257ac6d2755879d68796d637dd77025cc28b871e01
-  data.tar.gz: 2b7b59b031a8302f716abb8405bc9e7d67fce3077493b368924d53865e31475ee6356bd0c617a74ea32ac97ca600f572e306d62887aa40236bf87bc10e6ac4a4
+  metadata.gz: ee7d1248c446032c9940c3f63b8161e2c1350800c55bcff78bec2f0bf65363c2befcf2f135171f24c1987a996935d590e50b63b12dbc2bb3ddca7ce54ade95fd
+  data.tar.gz: ac9446088c14121f78cb7b53cce6cdaf3b71f8b0b1a1f89c8ec940ed8844e9f97eddaa87fb0533f4771fcd6fb3c0f8249edbba80b1f9d3adfbeb85dce5f60d49

data/.rubocop.yml

@@ -5,6 +5,7 @@ AllCops:
     - 'Rakefile'
     - 'bin/**/*'
     - 'vendor/**/*'
+    - 'spec/support/**/*'
     - 'docker_root/**/*'
 
 Style/StringLiterals:

data/CHANGELOG.md

@@ -1,12 +1,30 @@
 # [Unreleased]
 
 ## 🚀 Features
-- **Add keyboard actions**: Implemented keyboard interactions, including typing and key pressing.
-- **Add drag and drop action**: Implemented drag and drop bewteen elements
+- **Add specialized elements**: Added support for Select, Radio, and Checkbox elements with specific behaviors
+
+## 🛠 Core Enhancements
+- **Optimize element initialization**: Reduced redundant element searches by reusing element information
+- **Add native option select**: Added support for native select option handling
+- **Improve element attributes**: Exposed element attributes (node_id, object_id, root_id) for better control
+- **Add BotBrowser binary usage**: Integrated BotBrowser binary for improved automation capabilities
+
+# Changelog v0.0.2.pre
+
+## 🚀 Features
+- **Add keyboard actions**: Implemented keyboard interactions, including typing and key pressing
+- **Add drag and drop action**: Implemented drag and drop between elements
+- **Add b64 screenshot option**: Added support for base64 encoded screenshots
 
 ## 🛠 Core Enhancements
 - **Improve mouse movements**: Keep mouse position between interaction during browser session
 - **Improve mouse movements**: Improving Bézier curve usage for more human like behavior
+- **Add log level**: Added configurable logging levels
+- **Keep hardwares during session**: Maintain hardware state throughout the browser session
+- **Add magick find**: Enhanced element finding capabilities
+- **Refactor callFunctionOn usage**: Improved JavaScript function calling mechanism
+- **Add started? method**: New method to check browser startup status
+- **Wait for debug url**: Enhanced browser startup synchronization
 
 # Changelog v0.0.1.pre
 

data/Rakefile

@@ -57,7 +57,7 @@ namespace :chromate do
       browser.start
       browser.navigate_to("https://kaliiiiiiiiii.github.io/brotector")
       sleep 2
-      browser.click_element("#clickHere")
+      browser.find_element("#clickHere").click
       sleep 3
       browser.screenshot("results/brotector.png")
       browser.stop
@@ -86,7 +86,7 @@ namespace :chromate do
       browser.start
       browser.navigate_to("https://whatismyipaddress.com")
       sleep 2
-      browser.click_element('//*[@id="qc-cmp2-ui"]/div[2]/div/button[3]')
+      browser.find_element('//*[@id="qc-cmp2-ui"]/div[2]/div/button[3]').click
       browser.screenshot("results/my_ip.png")
       browser.stop
     end

data/docker_root/app.rb

@@ -40,26 +40,23 @@ class TestInDocker
   def click_features
     url = server_urls['where_clicked']
     browser.navigate_to(url)
-    browser.refresh
-    browser.click_element('#interactive-button')
+    browser.find_element('#interactive-button').click
     sleep 1
   end
 
   def move_features
     url = server_urls['where_moved']
     browser.navigate_to(url)
-    browser.refresh
-    browser.hover_element('#red')
-    browser.hover_element('#yellow')
-    browser.hover_element('#green')
-    browser.hover_element('#blue')
+    browser.find_element('#red').hover
+    browser.find_element('#yellow').hover
+    browser.find_element('#green').hover
+    browser.find_element('#blue').hover
     sleep 1
   end
 
   def drag_and_drop_features
     url = server_urls['drag_and_drop']
     browser.navigate_to(url)
-    browser.refresh
     blue_square = browser.find_element('#draggable')
     green_square = browser.find_element('#dropzone')
     blue_square.drop_to(green_square)
@@ -69,10 +66,9 @@ class TestInDocker
   def fill_form_features
     url = server_urls['fill_form']
     browser.navigate_to(url)
-    browser.refresh
     browser.find_element('#first-name').type('John')
     browser.find_element('#last-name').type('Doe')
-    browser.select_option('#gender', 'female')
+    browser.find_element('#gender').select_option('female')
     browser.find_element('#option-2').click
     browser.find_element('#submit-button').click
     sleep 1
@@ -81,7 +77,6 @@ class TestInDocker
   def shadow_dom_features
     url = server_urls['shadow_checkbox']
     browser.navigate_to(url)
-    browser.refresh
     shadow_container = browser.find_element('#shadow-container')
     checkbox = shadow_container.find_shadow_child('#shadow-checkbox')
     checkbox.click

data/docs/BOT_BROWSER.md

@@ -0,0 +1,74 @@
+# BotBrowser Documentation
+
+BotBrowser is a specialized configuration module for Chromate that helps you manage and use a specific Chrome browser installation for bot automation purposes.
+
+## Table of Contents
+
+1. [Installation](#installation)
+2. [Usage](#usage)
+3. [Configuration](#configuration)
+4. [API Reference](#api-reference)
+
+## Installation
+
+First, require the BotBrowser module in your Ruby code:
+
+```ruby
+require 'bot_browser'
+```
+
+Then, install the browser:
+
+```ruby
+# Install the latest version
+BotBrowser.install
+
+# Or install a specific version
+BotBrowser.install('v130')
+```
+
+## Usage
+
+Here's a basic example of how to use BotBrowser with Chromate:
+
+```ruby
+require 'bot_browser'
+
+# Install the browser if not already installed
+BotBrowser.install unless BotBrowser.installed?
+
+# Load the BotBrowser configuration
+BotBrowser.load
+
+# Create a new browser instance
+browser = Chromate::Browser.new
+
+# Use the browser as you would normally with Chromate
+browser.navigate_to('https://example.com')
+```
+
+## Configuration
+
+BotBrowser uses a configuration file located at `~/.botbrowser/config.yml`. This file is automatically created during installation and contains:
+
+- `bot_browser_path`: Path to the Chrome binary
+- `profile`: Path to the browser profile directory
+
+## API Reference
+
+### `BotBrowser.install(version = nil)`
+Installs the Chrome browser for bot automation.
+- `version`: Optional. Specific version to install. If not provided, installs the latest version.
+
+### `BotBrowser.uninstall`
+Removes the installed browser and its configuration.
+
+### `BotBrowser.installed?`
+Checks if the browser is installed.
+- Returns: `true` if installed, `false` otherwise.
+
+### `BotBrowser.load`
+Loads the BotBrowser configuration and sets up Chromate with the appropriate settings.
+- Configures Chrome binary path
+- Sets up browser profile
+- Configures necessary Chrome flags for bot automation

data/docs/browser.md

@@ -112,69 +112,35 @@ It will call `#xvfb_screenshot` private method if `xvfb` mode is `true`
 
 #### `#find_element(selector)`
 
-Finds a single element on the page using the specified CSS selector.
+Finds a single element on the page using the specified CSS selector. Returns a specialized element class based on the element type:
 
 - **Parameters:**
   - `selector` (String): The CSS selector to locate the element.
 
 - **Returns:**
-  - `Chromate::Element`: The found element.
+  - `Chromate::Elements::Select`: For `<select>` elements
+  - `Chromate::Elements::Option`: For `<option>` elements
+  - `Chromate::Elements::Radio`: For radio button inputs (`<input type="radio">`)
+  - `Chromate::Elements::Checkbox`: For checkbox inputs (`<input type="checkbox">`)
+  - `Chromate::Element`: For all other element types
 
-- **Example:**
-  ```ruby
-  element = browser.find_element('#my-element')
-  puts element.text
-  ```
-
-#### `#click_element(selector)`
-
-Finds an element by selector and clicks it.
+Each specialized element type provides specific methods for interacting with that type of element. For example:
 
-- **Parameters:**
-  - `selector` (String): The CSS selector of the element to click.
-
-- **Example:**
-  ```ruby
-  browser.click_element('#submit-button')
-  ```
-
-#### `#hover_element(selector)`
-
-Finds an element by selector and hovers over it.
-
-- **Parameters:**
-  - `selector` (String): The CSS selector of the element to hover.
-
-- **Example:**
-  ```ruby
-  browser.hover_element('#hover-target')
-  ```
-
-#### `#type_text(selector, text)`
-
-Finds an element by selector and types the specified text into it.
-
-- **Parameters:**
-  - `selector` (String): The CSS selector of the element.
-  - `text` (String): The text to type into the element.
-
-- **Example:**
-  ```ruby
-  browser.type_text('#input-field', 'Hello, Chromate!')
-  ```
-
-#### `#select_option(selector, option)`
+```ruby
+# Working with radio buttons
+radio = browser.find_element('input[type="radio"]')
+radio.check if !radio.checked?
 
-Selects an option from a dropdown element.
+# Working with checkboxes
+checkbox = browser.find_element('input[type="checkbox"]')
+checkbox.toggle
 
-- **Parameters:**
-  - `selector` (String): The CSS selector of the dropdown element.
-  - `option` (String): The value of the option to select.
+# Working with select elements
+select = browser.find_element('select#country')
+select.select_option('France')
+```
 
-- **Example:**
-  ```ruby
-  browser.select_option('#dropdown', 'option2')
-  ```
+See the [Element documentation](element.md) for more details about specialized elements.
 
 #### `#evaluate_script(script)`
 
@@ -216,5 +182,4 @@ browser.navigate_to('https://example.com')
 browser.screenshot('example.png')
 element = browser.find_element('#main-header')
 puts element.text
-browser.stop
-```
+browser.stop

data/docs/client.md

@@ -0,0 +1,126 @@
+# Client
+
+The `Chromate::Client` class is responsible for managing WebSocket connections to Chrome DevTools Protocol (CDP). It handles communication between the Chromate library and the Chrome browser, including message sending, receiving, and event handling.
+
+### Initialization
+
+```ruby
+client = Chromate::Client.new(browser)
+```
+
+- **Parameters:**
+  - `browser` (Chromate::Browser): The browser instance to connect to.
+
+### Public Methods
+
+#### `#start`
+
+Establishes the WebSocket connection to Chrome DevTools Protocol and sets up event handlers.
+
+- **Returns:**
+  - `self`: Returns the client instance for method chaining.
+
+- **Example:**
+  ```ruby
+  client.start
+  ```
+
+#### `#stop`
+
+Closes the WebSocket connection.
+
+- **Returns:**
+  - `self`: Returns the client instance for method chaining.
+
+- **Example:**
+  ```ruby
+  client.stop
+  ```
+
+#### `#send_message(method, params = {})`
+
+Sends a message to Chrome DevTools Protocol and waits for the response.
+
+- **Parameters:**
+  - `method` (String): The CDP method to call.
+  - `params` (Hash, optional): Parameters for the CDP method.
+
+- **Returns:**
+  - `Hash`: The response from Chrome DevTools Protocol.
+
+- **Example:**
+  ```ruby
+  result = client.send_message('DOM.getDocument')
+  ```
+
+#### `#reconnect`
+
+Reestablishes the WebSocket connection if it was lost.
+
+- **Returns:**
+  - `self`: Returns the client instance for method chaining.
+
+- **Example:**
+  ```ruby
+  client.reconnect
+  ```
+
+#### `#on_message`
+
+Subscribes to WebSocket messages. Allows different parts of the application to listen for CDP events.
+
+- **Parameters:**
+  - `&block` (Block): The block to execute when a message is received.
+
+- **Example:**
+  ```ruby
+  client.on_message do |message|
+    puts "Received message: #{message}"
+  end
+  ```
+
+### Class Methods
+
+#### `.listeners`
+
+Returns the array of registered message listeners.
+
+- **Returns:**
+  - `Array<Proc>`: The array of listener blocks.
+
+### Event Handling
+
+The client automatically handles several WebSocket events:
+
+- `:message`: Processes incoming CDP messages and notifies listeners
+- `:open`: Logs successful connection
+- `:error`: Logs WebSocket errors
+- `:close`: Logs connection closure
+
+### Error Handling
+
+The client includes automatic reconnection logic when message sending fails:
+
+- Attempts to reconnect to the WebSocket
+- Retries the failed message
+- Logs errors and debug information through `Chromate::CLogger`
+
+### Example Usage
+
+```ruby
+browser = Chromate::Browser.new
+client = Chromate::Client.new(browser)
+
+client.start
+
+# Send a CDP command
+result = client.send_message('DOM.getDocument')
+
+# Listen for specific events
+client.on_message do |msg|
+  puts msg if msg['method'] == 'DOM.documentUpdated'
+end
+
+# Clean up
+client.stop
+```

data/docs/element.md

@@ -15,6 +15,43 @@ element = Chromate::Element.new(selector, client, node_id: nil, object_id: nil,
   - `object_id` (String, optional): The object ID of the element.
   - `root_id` (Integer, optional): The root node ID of the document.
 
+### Attributes
+
+#### `#selector`
+
+Returns the CSS selector used to locate the element.
+
+- **Returns:**
+  - `String`: The CSS selector.
+
+#### `#client`
+
+Returns the CDP client instance used to communicate with the browser.
+
+- **Returns:**
+  - `Chromate::Client`: The CDP client instance.
+
+#### `#root_id`
+
+Returns the root node ID of the document.
+
+- **Returns:**
+  - `Integer`: The root node ID.
+
+#### `#object_id`
+
+Returns the object ID of the element.
+
+- **Returns:**
+  - `String`: The object ID.
+
+#### `#node_id`
+
+Returns the node ID of the element.
+
+- **Returns:**
+  - `Integer`: The node ID.
+
 ### Public Methods
 
 #### `#mouse`
@@ -74,6 +111,19 @@ Returns a hash of the element's attributes.
   puts "Element attributes: #{attributes}"
   ```
 
+#### `#tag_name`
+
+Gets the HTML tag name of the element in lowercase.
+
+- **Returns:**
+  - `String`: The HTML tag name.
+
+- **Example:**
+  ```ruby
+  tag = element.tag_name
+  puts "Tag name: #{tag}"
+  ```
+
 #### `#set_attribute(name, value)`
 
 Sets an attribute on the element.
@@ -283,7 +333,33 @@ Finds all child elements inside the shadow root using the given selector.
   shadow_elements.each { |el| puts el.text }
   ```
 
+#### `#value`
+
+Gets the value of the element.
+
+- **Returns:**
+  - `String`: The element's value.
+
+- **Example:**
+  ```ruby
+  value = element.value
+  puts "Element value: #{value}"
+  ```
+
 ### Exceptions
 
 - `NotFoundError`: Raised when an element cannot be found with the given selector.
-- `InvalidSelectorError`: Raised when the selector cannot resolve to a valid element.
+- `InvalidSelectorError`: Raised when the selector cannot resolve to a valid element.
+
+## Specialized Elements
+
+Chromate provides specialized element classes for specific HTML elements that have unique behaviors and methods. When using `find_element`, Chromate automatically returns the appropriate specialized element based on the element type.
+
+### Available Specialized Elements
+
+- [Select Element](elements/select.md): For `<select>` elements
+- [Option Element](elements/option.md): For `<option>` elements within select elements
+- [Radio Element](elements/radio.md): For radio button inputs (`<input type="radio">`)
+- [Checkbox Element](elements/checkbox.md): For checkbox inputs (`<input type="checkbox">`)
+
+Each specialized element inherits from the base `Element` class and adds specific methods for interacting with that type of element. See the individual documentation files for details on the methods available for each element type.

data/docs/elements/checkbox.md

@@ -0,0 +1,69 @@
+# Checkbox Element
+
+The `Chromate::Elements::Checkbox` class represents a checkbox input element in the browser. It extends the base `Element` class with specific functionality for checkboxes.
+
+### Initialization
+
+```ruby
+checkbox = Chromate::Elements::Checkbox.new(selector, client, **options)
+```
+
+- **Parameters:**
+  - `selector` (String): The CSS selector used to locate the checkbox.
+  - `client` (Chromate::Client): An instance of the CDP client.
+  - `options` (Hash): Additional options passed to the Element constructor.
+    - `object_id` (String): Optional. The object ID of a pre-searched element.
+    - `node_id` (Integer): Optional. The node ID of a pre-searched element.
+    - `root_id` (Integer): Optional. The root ID of a pre-searched element.
+
+### Public Methods
+
+#### `#checked?`
+
+Returns whether the checkbox is currently checked.
+
+- **Returns:**
+  - `Boolean`: `true` if the checkbox is checked, `false` otherwise.
+
+- **Example:**
+  ```ruby
+  if checkbox.checked?
+    puts "Checkbox is checked"
+  end
+  ```
+
+#### `#check`
+
+Checks the checkbox if it's not already checked.
+
+- **Returns:**
+  - `self`: Returns the checkbox element for method chaining.
+
+- **Example:**
+  ```ruby
+  checkbox.check
+  ```
+
+#### `#uncheck`
+
+Unchecks the checkbox if it's currently checked.
+
+- **Returns:**
+  - `self`: Returns the checkbox element for method chaining.
+
+- **Example:**
+  ```ruby
+  checkbox.uncheck
+  ```
+
+#### `#toggle`
+
+Toggles the checkbox state (checks if unchecked, unchecks if checked).
+
+- **Returns:**
+  - `self`: Returns the checkbox element for method chaining.
+
+- **Example:**
+  ```ruby
+  checkbox.toggle
+  ```

data/docs/elements/radio.md

@@ -0,0 +1,57 @@
+# Radio Element
+
+The `Chromate::Elements::Radio` class represents a radio button input element in the browser. It extends the base `Element` class with specific functionality for radio buttons.
+
+### Initialization
+
+```ruby
+radio = Chromate::Elements::Radio.new(selector, client, **options)
+```
+
+- **Parameters:**
+  - `selector` (String): The CSS selector used to locate the radio button.
+  - `client` (Chromate::Client): An instance of the CDP client.
+  - `options` (Hash): Additional options passed to the Element constructor.
+    - `object_id` (String): Optional. The object ID of a pre-searched element.
+    - `node_id` (Integer): Optional. The node ID of a pre-searched element.
+    - `root_id` (Integer): Optional. The root ID of a pre-searched element.
+
+### Public Methods
+
+#### `#checked?`
+
+Returns whether the radio button is currently checked.
+
+- **Returns:**
+  - `Boolean`: `true` if the radio button is checked, `false` otherwise.
+
+- **Example:**
+  ```ruby
+  if radio.checked?
+    puts "Radio button is checked"
+  end
+  ```
+
+#### `#check`
+
+Checks the radio button if it's not already checked.
+
+- **Returns:**
+  - `self`: Returns the radio element for method chaining.
+
+- **Example:**
+  ```ruby
+  radio.check
+  ```
+
+#### `#uncheck`
+
+Unchecks the radio button if it's currently checked.
+
+- **Returns:**
+  - `self`: Returns the radio element for method chaining.
+
+- **Example:**
+  ```ruby
+  radio.uncheck
+  ```