chromate-rb 0.0.1.pre → 0.0.2.pre

data/lib/chromate/configuration.rb

@@ -9,25 +9,27 @@ module Chromate
     include Helpers
     include Exceptions
     DEFAULT_ARGS = [
-      '--no-first-run',
-      '--no-default-browser-check',
-      '--disable-blink-features=AutomationControlled',
-      '--disable-extensions',
-      '--disable-infobars',
-      '--no-sandbox',
-      '--disable-popup-blocking',
-      '--ignore-certificate-errors',
-      '--disable-gpu',
-      '--disable-dev-shm-usage',
+      '--no-first-run', # Skip the first run wizard
+      '--no-default-browser-check', # Disable the default browser check
+      '--disable-blink-features=AutomationControlled', # Disable the AutomationControlled feature
+      '--disable-extensions', # Disable extensions
+      '--disable-infobars', # Disable the infobar that asks if you want to install Chrome
+      '--no-sandbox', # Required for chrome devtools to work
+      '--test-type', # Remove the not allowed message for --no-sandbox flag
+      '--disable-dev-shm-usage', # Disable /dev/shm usage
+      '--disable-gpu', # Disable the GPU
+      '--disable-popup-blocking', # Disable popup blocking
+      '--ignore-certificate-errors', # Ignore certificate errors
       '--window-size=1920,1080', # TODO: Make this automatic
-      '--hide-crash-restore-bubble'
+      '--hide-crash-restore-bubble' # Hide the crash restore bubble
     ].freeze
     HEADLESS_ARGS = [
       '--headless=new',
       '--window-position=2400,2400'
     ].freeze
     XVFB_ARGS = [
-      '--window-position=0,0'
+      '--window-position=0,0',
+      '--start-fullscreen'
     ].freeze
     DISABLED_FEATURES = %w[
       Translate
@@ -45,14 +47,15 @@ module Chromate
       enable-automation
     ].freeze
 
-    attr_accessor :user_data_dir, :headless, :xfvb, :native_control, :args, :headless_args, :xfvb_args, :exclude_switches, :proxy,
-                  :disable_features
+    attr_accessor :user_data_dir, :headless, :xfvb, :native_control, :startup_patch,
+                  :args, :headless_args, :xfvb_args, :exclude_switches, :proxy, :disable_features
 
     def initialize
       @user_data_dir      = File.expand_path('~/.config/google-chrome/Default')
       @headless           = true
       @xfvb               = false
       @native_control     = false
+      @startup_patch      = true
       @proxy              = nil
       @args               = [] + DEFAULT_ARGS
       @headless_args      = [] + HEADLESS_ARGS
@@ -63,18 +66,27 @@ module Chromate
       @args << '--use-angle=metal' if mac?
     end
 
+    # @return [Chromate::Configuration]
     def self.config
       @config ||= Configuration.new
     end
 
+    # @yield [Chromate::Configuration]
     def self.configure
       yield(config)
     end
 
+    # @return [Chromate::Configuration]
     def config
       self.class.config
     end
 
+    # @return [Boolean]
+    def patch?
+      @startup_patch
+    end
+
+    # @return [String]
     def chrome_path
       return ENV['CHROME_BIN'] if ENV['CHROME_BIN']
 
@@ -89,6 +101,10 @@ module Chromate
       end
     end
 
+    # @option [Boolean] headless
+    # @option [Boolean] xfvb
+    # @option [Hash] proxy
+    # @option [Array<String>] disable_features
     def generate_arguments(headless: @headless, xfvb: @xfvb, proxy: @proxy, disable_features: @disable_features, **_args)
       dynamic_args = []
 
@@ -100,6 +116,7 @@ module Chromate
       @args + dynamic_args
     end
 
+    # @return [Hash]
     def options
       {
         chrome_path: chrome_path,

data/lib/chromate/element.rb

@@ -13,7 +13,7 @@ module Chromate
         super("Unable to resolve element with selector: #{selector}")
       end
     end
-    attr_reader :selector, :client, :mouse
+    attr_reader :selector, :client
 
     # @param [String] selector
     # @param [Chromate::Client] client
@@ -26,36 +26,41 @@ module Chromate
       @object_id  = object_id
       @node_id    = node_id
       @object_id, @node_id = find(selector, root_id) unless @object_id && @node_id
-      @root_id  = root_id || document['root']['nodeId']
-      @mouse    = Hardwares.mouse(client: client, element: self)
+      @root_id = root_id || document['root']['nodeId']
+    end
+
+    # @return [Chromate::Hardwares::MouseController]
+    def mouse
+      @mouse ||= Hardwares.mouse(client: client, element: self)
     end
 
+    # @return [Chromate::Hardwares::KeyboardController]
+    def keyboard
+      @keyboard ||= Hardwares.keyboard(client: client, element: self)
+    end
+
+    # @return [String]
     def inspect
       value = selector.length > 20 ? "#{selector[0..20]}..." : selector
       "#<Chromate::Element:#{value}>"
     end
 
+    # @return [String]
     def text
-      return @text if @text
-
       result = client.send_message('Runtime.callFunctionOn', functionDeclaration: 'function() { return this.innerText; }', objectId: @object_id)
-      @text = result['result']['value']
+      result['result']['value']
     end
 
     # @return [String]
     def html
-      return @html if @html
-
-      @html = client.send_message('DOM.getOuterHTML', objectId: @object_id)
-      @html = @html['outerHTML']
+      html = client.send_message('DOM.getOuterHTML', objectId: @object_id)
+      html['outerHTML']
     end
 
     # @return [Hash]
     def attributes
-      return @attributes if @attributes
-
       result = client.send_message('DOM.getAttributes', nodeId: @node_id)
-      @attributes = Hash[*result['attributes']]
+      Hash[*result['attributes']]
     end
 
     # @param [String] name
@@ -94,6 +99,13 @@ module Chromate
       bounding_box['height']
     end
 
+    # @return [self]
+    def focus
+      client.send_message('DOM.focus', nodeId: @node_id)
+
+      self
+    end
+
     # @return [self]
     def click
       mouse.click
@@ -109,9 +121,24 @@ module Chromate
     end
 
     # @param [String] text
+    # @return [self]
     def type(text)
-      client.send_message('Runtime.callFunctionOn', functionDeclaration: "function(value) { this.value = value; this.dispatchEvent(new Event('input')); }",
-                                                    objectId: @object_id, arguments: [{ value: text }])
+      focus
+      keyboard.type(text)
+
+      self
+    end
+
+    # @return [self]
+    def press_enter
+      keyboard.press_key('Enter')
+      submit_parent_form
+
+      self
+    end
+
+    def drop_to(element)
+      mouse.drag_and_drop_to(element)
 
       self
     end
@@ -171,6 +198,8 @@ module Chromate
 
     private
 
+    # @param [String] event
+    # @return [void]
     def dispatch_event(event)
       client.send_message('DOM.dispatchEvent', nodeId: @node_id, type: event)
     end
@@ -190,5 +219,26 @@ module Chromate
     def document
       @document ||= client.send_message('DOM.getDocument')
     end
+
+    def submit_parent_form
+      script = <<~JAVASCRIPT
+        function() {
+          const form = this.closest('form');
+          if (form) {
+            const submitEvent = new Event('submit', {
+              bubbles: true,
+              cancelable: true
+            });
+            if (form.dispatchEvent(submitEvent)) {
+              form.submit();
+            }
+          }
+        }
+      JAVASCRIPT
+
+      client.send_message('Runtime.callFunctionOn',
+                          functionDeclaration: script,
+                          objectId: @object_id)
+    end
   end
 end

data/lib/chromate/elements/select.rb

@@ -5,14 +5,66 @@ require 'chromate/element'
 module Chromate
   module Elements
     class Select < Element
-      # @param [String] selector
+      # @param [String] value
+      # @return [self]
       def select_option(value)
-        click
-        opt = find_elements('option').find do |option|
-          option.attributes['value'] == value
-        end
-        opt.set_attribute('selected', 'true')
-        click
+        script = javascript
+
+        client.send_message('Runtime.callFunctionOn',
+                            functionDeclaration: script,
+                            objectId: @object_id,
+                            arguments: [{ value: value }])
+
+        self
+      rescue StandardError => e
+        raise ArgumentError, "Option '#{value}' not found in select" if e.message.include?('Option')
+
+        raise e
+      end
+
+      # @return [String|nil]
+      def selected_value
+        result = client.send_message('Runtime.callFunctionOn',
+                                     functionDeclaration: 'function() { return this.value; }',
+                                     objectId: @object_id)
+        result.dig('result', 'value')
+      end
+
+      # @return [String|nil]
+      def selected_text
+        result = client.send_message('Runtime.callFunctionOn',
+                                     functionDeclaration: 'function() {
+            const option = this.options[this.selectedIndex];
+            return option ? option.textContent.trim() : null;
+          }',
+                                     objectId: @object_id)
+        result.dig('result', 'value')
+      end
+
+      # @return [String]
+      def javascript
+        <<~JAVASCRIPT
+          function() {
+            this.focus();
+            this.dispatchEvent(new MouseEvent('mousedown'));
+
+            const options = Array.from(this.options);
+            const option = options.find(opt =>#{" "}
+              opt.value === arguments[0] || opt.textContent.trim() === arguments[0]
+            );
+
+            if (!option) {
+              throw new Error(`Option '${arguments[0]}' not found in select`);
+            }
+
+            this.value = option.value;
+
+            this.dispatchEvent(new Event('change', { bubbles: true }));
+            this.dispatchEvent(new Event('input', { bubbles: true }));
+
+            this.blur();
+          }
+        JAVASCRIPT
       end
     end
   end

data/lib/chromate/hardwares/keyboard_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Hardwares
+    class KeyboardController
+      attr_accessor :element, :client
+
+      # @param [Chromate::Element] element
+      # @param [Chromate::Client] client
+      def initialize(element: nil, client: nil)
+        @element        = element
+        @client         = client
+        @type_interval  = rand(0.05..0.1)
+      end
+
+      # @param [String] key
+      # @return [self]
+      def press_key(_key)
+        raise NotImplementedError
+      end
+
+      # @param [String] text
+      # @return [self]
+      def type(text)
+        text.each_char do |char|
+          press_key(char)
+          sleep(@type_interval)
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/chromate/hardwares/keyboards/virtual_controller.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Hardwares
+    module Keyboards
+      class VirtualController < Chromate::Hardwares::KeyboardController
+        def press_key(key = 'Enter')
+          params = {
+            key: key,
+            code: key_to_code(key),
+            windowsVirtualKeyCode: key_to_virtual_code(key)
+          }
+
+          params[:text] = key if key.length == 1
+
+          # Dispatch keyDown event
+          client.send_message('Input.dispatchKeyEvent', params.merge(type: 'keyDown'))
+
+          # Dispatch keyUp event
+          client.send_message('Input.dispatchKeyEvent', params.merge(type: 'keyUp'))
+
+          self
+        end
+
+        private
+
+        # @param [String] key
+        # @return [String]
+        def key_to_code(key)
+          case key
+          when 'Enter' then 'Enter'
+          when 'Tab' then 'Tab'
+          when 'Backspace' then 'Backspace'
+          when 'Delete' then 'Delete'
+          when 'Escape' then 'Escape'
+          when 'ArrowLeft' then 'ArrowLeft'
+          when 'ArrowRight' then 'ArrowRight'
+          when 'ArrowUp' then 'ArrowUp'
+          when 'ArrowDown' then 'ArrowDown'
+          else
+            "Key#{key.upcase}"
+          end
+        end
+
+        # @param [String] key
+        # @return [Integer]
+        def key_to_virtual_code(key)
+          case key
+          when 'Enter' then 0x0D
+          when 'Tab' then 0x09
+          when 'Backspace' then 0x08
+          when 'Delete' then 0x2E
+          when 'Escape' then 0x1B
+          when 'ArrowLeft' then 0x25
+          when 'ArrowRight' then 0x27
+          when 'ArrowUp' then 0x26
+          when 'ArrowDown' then 0x28
+          else
+            key.upcase.ord
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chromate/hardwares/mouse_controller.rb

@@ -6,62 +6,98 @@ module Chromate
       CLICK_DURATION_RANGE = (0.01..0.1)
       DOUBLE_CLICK_DURATION_RANGE = (0.1..0.5)
 
-      attr_accessor :element, :client, :mouse_position
+      def self.reset_mouse_position
+        @@mouse_position = { x: 0, y: 0 } # rubocop:disable Style/ClassVars
+      end
+
+      attr_accessor :element, :client
 
       # @param [Chromate::Element] element
       # @param [Chromate::Client] client
       def initialize(element: nil, client: nil)
         @element        = element
         @client         = client
-        @mouse_position = { x: 0, y: 0 }
       end
 
+      # @return [Hash]
+      def mouse_position
+        @@mouse_position ||= { x: 0, y: 0 } # rubocop:disable Style/ClassVars
+      end
+
+      # @return [self]
       def hover
         raise NotImplementedError
       end
 
+      # @return [self]
       def click
         raise NotImplementedError
       end
 
+      # @return [self]
       def double_click
         raise NotImplementedError
       end
 
+      # @return [self]
       def right_click
         raise NotImplementedError
       end
 
+      # @params [Chromate::Element] element
+      # @return [self]
+      def drag_and_drop_to(element)
+        raise NotImplementedError
+      end
+
+      # @return [Integer]
       def position_x
         mouse_position[:x]
       end
 
+      # @return [Integer]
       def position_y
         mouse_position[:y]
       end
 
       private
 
+      # @return [Integer]
       def target_x
         element.x + (element.width / 2)
       end
 
+      # @return [Integer]
       def target_y
         element.y + (element.height / 2)
       end
 
-      def bezier_curve(steps: 50) # rubocop:disable Metrics/AbcSize
-        control_x = (target_x / 2)
-        control_y = (target_y / 2)
+      # @param [Integer] steps
+      # @return [Array<Hash>]
+      def bezier_curve(steps:, start_x: position_x, start_y: position_y, t_x: target_x, t_y: target_y) # rubocop:disable Metrics/AbcSize
+        # Points for the Bézier curve
+        control_x1 = start_x + (rand(50..150) * (t_x > start_x ? 1 : -1))
+        control_y1 = start_y + (rand(50..150) * (t_y > start_y ? 1 : -1))
+        control_x2 = t_x + (rand(50..150) * (t_x > start_x ? -1 : 1))
+        control_y2 = t_y + (rand(50..150) * (t_y > start_y ? -1 : 1))
 
-        (0..steps).map do |t|
-          t /= steps.to_f
-          # Compute the position on the quadratic Bezier curve
-          new_x = (((1 - t)**2) * position_x) + (2 * (1 - t) * t * control_x) + ((t**2) * target_x)
-          new_y = (((1 - t)**2) * position_y) + (2 * (1 - t) * t * control_y) + ((t**2) * target_y)
-          { x: new_x, y: new_y }
+        (0..steps).map do |i|
+          t = i.to_f / steps
+          x = (((1 - t)**3) * start_x) + (3 * ((1 - t)**2) * t * control_x1) + (3 * (1 - t) * (t**2) * control_x2) + ((t**3) * t_x)
+          y = (((1 - t)**3) * start_y) + (3 * ((1 - t)**2) * t * control_y1) + (3 * (1 - t) * (t**2) * control_y2) + ((t**3) * t_y)
+          { x: x, y: y }
         end
       end
+
+      # @param [Integer] target_x
+      # @param [Integer] target_y
+      # @return [Hash]
+      def update_mouse_position(target_x, target_y)
+        @@mouse_position[:x] = target_x
+        @@mouse_position[:y] = target_y
+
+        mouse_position
+      end
     end
   end
 end