chromate-rb 0.0.1.pre

data/lib/chromate/element.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Chromate
+  class Element
+    class NotFoundError < StandardError
+      def initialize(selector, root_id)
+        super("Element not found with selector: #{selector} under root_id: #{root_id}")
+      end
+    end
+
+    class InvalidSelectorError < StandardError
+      def initialize(selector)
+        super("Unable to resolve element with selector: #{selector}")
+      end
+    end
+    attr_reader :selector, :client, :mouse
+
+    # @param [String] selector
+    # @param [Chromate::Client] client
+    # @option [Integer] node_id
+    # @option [String] object_id
+    # @option [Integer] root_id
+    def initialize(selector, client, node_id: nil, object_id: nil, root_id: nil)
+      @selector   = selector
+      @client     = client
+      @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)
+    end
+
+    def inspect
+      value = selector.length > 20 ? "#{selector[0..20]}..." : selector
+      "#<Chromate::Element:#{value}>"
+    end
+
+    def text
+      return @text if @text
+
+      result = client.send_message('Runtime.callFunctionOn', functionDeclaration: 'function() { return this.innerText; }', objectId: @object_id)
+      @text = result['result']['value']
+    end
+
+    # @return [String]
+    def html
+      return @html if @html
+
+      @html = client.send_message('DOM.getOuterHTML', objectId: @object_id)
+      @html = @html['outerHTML']
+    end
+
+    # @return [Hash]
+    def attributes
+      return @attributes if @attributes
+
+      result = client.send_message('DOM.getAttributes', nodeId: @node_id)
+      @attributes = Hash[*result['attributes']]
+    end
+
+    # @param [String] name
+    # @param [String] value
+    # @return [self]
+    def set_attribute(name, value)
+      client.send_message('DOM.setAttributeValue', nodeId: @node_id, name: name, value: value)
+      dispatch_event('change')
+    end
+
+    # @return [Hash]
+    def bounding_box
+      return @bounding_box if @bounding_box
+
+      result = client.send_message('DOM.getBoxModel', objectId: @object_id)
+      @bounding_box = result['model']
+    end
+
+    # @return [Integer]
+    def x
+      bounding_box['content'][0]
+    end
+
+    # @return [Integer]
+    def y
+      bounding_box['content'][1]
+    end
+
+    # @return [Integer]
+    def width
+      bounding_box['width']
+    end
+
+    # @return [Integer]
+    def height
+      bounding_box['height']
+    end
+
+    # @return [self]
+    def click
+      mouse.click
+
+      self
+    end
+
+    # @return [self]
+    def hover
+      mouse.hover
+
+      self
+    end
+
+    # @param [String] text
+    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 }])
+
+      self
+    end
+
+    # @param [String] selector
+    # @return [Chromate::Element]
+    def find_element(selector)
+      find_elements(selector, max: 1).first
+    end
+
+    # @param [String] selector
+    # @option [Integer] max
+    # @return [Array<Chromate::Element>]
+    def find_elements(selector, max: 0)
+      results = client.send_message('DOM.querySelectorAll', nodeId: @node_id, selector: selector)
+      results['nodeIds'].each_with_index.filter_map do |node_id, idx|
+        node_info = client.send_message('DOM.resolveNode', nodeId: node_id)
+        next unless node_info['object']
+        break if max.positive? && idx >= max
+
+        Element.new(selector, client, node_id: node_id, object_id: node_info['object']['objectId'], root_id: @node_id)
+      end
+    end
+
+    # @return [Integer]
+    def shadow_root_id
+      return @shadow_root_id if @shadow_root_id
+
+      node_info = client.send_message('DOM.describeNode', nodeId: @node_id)
+      @shadow_root_id = node_info.dig('node', 'shadowRoots', 0, 'nodeId')
+    end
+
+    # @return [Boolean]
+    def shadow_root?
+      !!shadow_root_id
+    end
+
+    # @param [String] selector
+    # @return [Chromate::Element|NilClass]
+    def find_shadow_child(selector)
+      find_shadow_children(selector).first
+    end
+
+    # @param [String] selector
+    # @return [Array<Chromate::Element>]
+    def find_shadow_children(selector)
+      return [] unless shadow_root?
+
+      results = client.send_message('DOM.querySelectorAll', nodeId: shadow_root_id, selector: selector)
+      (results&.dig('nodeIds') || []).map do |node_id|
+        node_info = client.send_message('DOM.resolveNode', nodeId: node_id)
+        next unless node_info['object']
+
+        Element.new(selector, client, node_id: node_id, object_id: node_info['object']['objectId'], root_id: shadow_root_id)
+      end
+    end
+
+    private
+
+    def dispatch_event(event)
+      client.send_message('DOM.dispatchEvent', nodeId: @node_id, type: event)
+    end
+
+    # @return [Array] [object_id, node_id]
+    def find(selector, root_id = nil)
+      @root_id  = root_id || document['root']['nodeId']
+      result    = client.send_message('DOM.querySelector', nodeId: @root_id, selector: selector)
+      raise NotFoundError.new(selector, @root_id) unless result['nodeId']
+
+      node_info = client.send_message('DOM.resolveNode', nodeId: result['nodeId'])
+      raise InvalidSelectorError, selector unless node_info['object']
+
+      [node_info['object']['objectId'], result['nodeId']]
+    end
+
+    def document
+      @document ||= client.send_message('DOM.getDocument')
+    end
+  end
+end

data/lib/chromate/elements/select.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'chromate/element'
+
+module Chromate
+  module Elements
+    class Select < Element
+      # @param [String] selector
+      def select_option(value)
+        click
+        opt = find_elements('option').find do |option|
+          option.attributes['value'] == value
+        end
+        opt.set_attribute('selected', 'true')
+        click
+      end
+    end
+  end
+end

data/lib/chromate/exceptions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Exceptions
+    class ChromateError < StandardError; end
+    class InvalidBrowserError < ChromateError; end
+    class InvalidPlatformError < ChromateError; end
+  end
+end

data/lib/chromate/hardwares/mouse_controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Hardwares
+    class MouseController
+      CLICK_DURATION_RANGE = (0.01..0.1)
+      DOUBLE_CLICK_DURATION_RANGE = (0.1..0.5)
+
+      attr_accessor :element, :client, :mouse_position
+
+      # @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
+
+      def hover
+        raise NotImplementedError
+      end
+
+      def click
+        raise NotImplementedError
+      end
+
+      def double_click
+        raise NotImplementedError
+      end
+
+      def right_click
+        raise NotImplementedError
+      end
+
+      def position_x
+        mouse_position[:x]
+      end
+
+      def position_y
+        mouse_position[:y]
+      end
+
+      private
+
+      def target_x
+        element.x + (element.width / 2)
+      end
+
+      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)
+
+        (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 }
+        end
+      end
+    end
+  end
+end

data/lib/chromate/hardwares/mouses/linux_controller.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'chromate/helpers'
+require 'open3'
+
+module Chromate
+  module Hardwares
+    module Mouses
+      class LinuxController < MouseController
+        class InvalidPlatformError < StandardError; end
+        include Helpers
+
+        LEFT_BUTTON = 1
+        RIGHT_BUTTON = 3
+
+        def initialize(element: nil, client: nil)
+          raise InvalidPlatformError, 'MouseController is only supported on Linux' unless linux?
+
+          super
+        end
+
+        def hover
+          focus_chrome_window
+          # system("xdotool mousemove_relative --sync -- #{x} #{y}")
+          system("xdotool mousemove #{target_x} #{target_y}")
+          current_mouse_position
+        end
+
+        def click
+          hover
+          simulate_button_event(LEFT_BUTTON, true)
+          simulate_button_event(LEFT_BUTTON, false)
+        end
+
+        def right_click
+          simulate_button_event(RIGHT_BUTTON, true)
+          simulate_button_event(RIGHT_BUTTON, false)
+        end
+
+        def double_click
+          click
+          sleep(rand(DOUBLE_CLICK_DURATION_RANGE))
+          click
+        end
+
+        private
+
+        def focus_chrome_window
+          # Recherche de la fenêtre Chrome avec xdotool
+          chrome_window_id = `xdotool search --onlyvisible --name "Chrome"`.strip
+
+          if chrome_window_id.empty?
+            puts 'Aucune fenêtre Chrome trouvée'
+          else
+            # Active la fenêtre Chrome avec xdotool
+            system("xdotool windowactivate #{chrome_window_id}")
+          end
+        end
+
+        def current_mouse_position
+          x = nil
+          y = nil
+          Open3.popen3('xdotool getmouselocation --shell') do |_, stdout, _, _|
+            output = stdout.read
+            x = output.match(/X=(\d+)/)[1].to_i
+            y = output.match(/Y=(\d+)/)[1].to_i
+          end
+
+          { x: x, y: y }
+        end
+
+        def simulate_button_event(button, press)
+          action = press ? 'mousedown' : 'mouseup'
+          system("xdotool #{action} #{button}")
+        end
+      end
+    end
+  end
+end

data/lib/chromate/hardwares/mouses/mac_os_controller.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'chromate/helpers'
+module Chromate
+  module Hardwares
+    module Mouses
+      class MacOsController < MouseController
+        class InvalidPlatformError < StandardError; end
+        include Helpers
+        extend FFI::Library
+
+        ffi_lib '/System/Library/Frameworks/ApplicationServices.framework/ApplicationServices'
+
+        class CGPoint < FFI::Struct
+          layout :x, :float,
+                 :y, :float
+        end
+
+        attach_function :CGEventCreateMouseEvent, [:pointer, :uint32, CGPoint.by_value, :uint32], :pointer
+        attach_function :CGEventPost, %i[uint32 pointer], :void
+        attach_function :CGEventSetType, %i[pointer uint32], :void
+        attach_function :CFRelease, [:pointer], :void
+        attach_function :CGMainDisplayID, [], :uint32
+        attach_function :CGEventCreate, [:pointer], :pointer
+        attach_function :CGEventGetLocation, [:pointer], CGPoint.by_value
+        attach_function :CGDisplayPixelsHigh, [:uint32], :size_t
+
+        class CGSize < FFI::Struct
+          layout :width, :float,
+                 :height, :float
+        end
+
+        LEFT_DOWN   = 1
+        LEFT_UP     = 2
+        RIGHT_DOWN  = 3
+        RIGHT_UP    = 4
+        MOUSE_MOVED = 5
+
+        def initialize(element: nil, client: nil)
+          raise InvalidPlatformError, 'MouseController is only supported on macOS' unless mac?
+
+          super
+          @main_display = CGMainDisplayID()
+          @display_height = CGDisplayPixelsHigh(@main_display).to_f
+          @scale_factor = determine_scale_factor
+        end
+
+        def hover
+          point = convert_coordinates(target_x, target_y)
+          create_and_post_event(MOUSE_MOVED, point)
+          current_mouse_position
+        end
+
+        def click
+          current_pos = current_mouse_position
+          create_and_post_event(LEFT_DOWN, current_pos)
+          create_and_post_event(LEFT_UP, current_pos)
+        end
+
+        def right_click
+          current_pos = current_mouse_position
+          create_and_post_event(RIGHT_DOWN, current_pos)
+          create_and_post_event(RIGHT_UP, current_pos)
+        end
+
+        def double_click
+          click
+          sleep(rand(DOUBLE_CLICK_DURATION_RANGE))
+          click
+        end
+
+        private
+
+        def create_and_post_event(event_type, point)
+          event = CGEventCreateMouseEvent(nil, event_type, point, 0)
+          CGEventPost(0, event)
+          CFRelease(event)
+        end
+
+        def current_mouse_position
+          event = CGEventCreate(nil)
+          return CGPoint.new if event.null?
+
+          system_point = CGEventGetLocation(event)
+          CFRelease(event)
+
+          # Convertir les coordonnées système en coordonnées navigateur
+          browser_x = system_point[:x] / @scale_factor
+          browser_y = (@display_height - system_point[:y]) / @scale_factor
+
+          @mouse_position = {
+            x: browser_x,
+            y: browser_y
+          }
+
+          # Retourner un nouveau CGPoint avec les coordonnées système
+          CGPoint.new.tap do |p|
+            p[:x] = system_point[:x]
+            p[:y] = system_point[:y]
+          end
+        end
+
+        def convert_coordinates(browser_x, browser_y)
+          # Convertir les coordonnées du navigateur en coordonnées système
+          system_x = browser_x * @scale_factor
+          system_y = @display_height - (browser_y * @scale_factor)
+
+          CGPoint.new.tap do |p|
+            p[:x] = system_x
+            p[:y] = system_y
+          end
+        end
+
+        def determine_scale_factor
+          # Obtenir le facteur d'échelle en comparant les dimensions logiques et physiques
+          # Par défaut, utiliser 2.0 pour les écrans Retina
+
+          `system_profiler SPDisplaysDataType | grep -i "retina"`.empty? ? 1.0 : 2.0
+        rescue StandardError
+          2.0 # Par défaut pour les écrans Retina modernes
+        end
+      end
+    end
+  end
+end
+
+# Test
+# require 'chromate/hardwares/mouses/mac_os_controller'
+# require 'ostruct'
+# element = OpenStruct.new(x: 500, y: 300, width: 100, height: 100)
+# mouse = Chromate::Hardwares::Mouse::MacOsController.new(element: element)
+# mouse.hover

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Hardwares
+    module Mouses
+      class VirtualController < Chromate::Hardwares::MouseController
+        def hover
+          steps     = rand(25..50)
+          points    = bezier_curve(steps: steps)
+          duration  = rand(0.1..0.3)
+
+          points.each do |point|
+            dispatch_mouse_event('mouseMoved', point[:x], point[:y])
+            sleep(duration / steps)
+          end
+
+          update_mouse_position(points.last[:x], points.last[:y])
+        end
+
+        def click
+          hover
+          click!
+        end
+
+        def double_click
+          click
+          sleep(rand(DOUBLE_CLICK_DURATION_RANGE))
+          click
+        end
+
+        def right_click
+          hover
+          dispatch_mouse_event('mousePressed', target_x, target_y, button: 'right', click_count: 1)
+          sleep(rand(CLICK_DURATION_RANGE))
+          dispatch_mouse_event('mouseReleased', target_x, target_y, button: 'right', click_count: 1)
+        end
+
+        private
+
+        def click!
+          dispatch_mouse_event('mousePressed', target_x, target_y, button: 'left', click_count: 1)
+          sleep(rand(CLICK_DURATION_RANGE))
+          dispatch_mouse_event('mouseReleased', target_x, target_y, button: 'left', click_count: 1)
+        end
+
+        # @param [String] type mouseMoved, mousePressed, mouseReleased
+        # @param [Integer] target_x
+        # @param [Integer] target_y
+        # @option [String] button
+        # @option [Integer] click_count
+        def dispatch_mouse_event(type, target_x, target_y, button: 'none', click_count: 0)
+          params = {
+            type: type,
+            x: target_x,
+            y: target_y,
+            button: button,
+            clickCount: click_count,
+            deltaX: 0,
+            deltaY: 0,
+            modifiers: 0,
+            timestamp: (Time.now.to_f * 1000).to_i
+          }
+
+          client.send_message('Input.dispatchMouseEvent', params)
+        end
+
+        def update_mouse_position(target_x, target_y)
+          @mouse_position[:x] = target_x
+          @mouse_position[:y] = target_y
+        end
+      end
+    end
+  end
+end
+
+# Test
+# require 'chromate/hardwares/mouses/virtual_controller'
+# require 'ostruct'
+# element = OpenStruct.new(x: 500, y: 300, width: 100, height: 100)
+# mouse = Chromate::Hardwares::Mouse::VirtualController.new(element: element)
+# mouse.hover

data/lib/chromate/hardwares.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'chromate/c_logger'
+require 'chromate/hardwares/mouse_controller'
+require 'chromate/hardwares/mouses/virtual_controller'
+require 'chromate/helpers'
+
+module Chromate
+  module Hardwares
+    extend Helpers
+
+    def mouse(**args)
+      browser = args[:client].browser
+      if browser.options[:native_control]
+        if mac?
+          Chromate::CLogger.log('🐁 Loading MacOs mouse controller')
+          require 'chromate/hardwares/mouses/mac_os_controller'
+          return Mouses::MacOsController.new(**args)
+        end
+        if linux?
+          Chromate::CLogger.log('🐁 Loading Linux mouse controller')
+          require 'chromate/hardwares/mouses/linux_controller'
+          return Mouses::LinuxController.new(**args)
+        end
+        raise 'Native mouse controller is not supported on Windows' if windows?
+      else
+        Chromate::CLogger.log('🐁 Loading Virtual mouse controller')
+        Mouses::VirtualController.new(**args)
+      end
+    end
+    module_function :mouse
+  end
+end

data/lib/chromate/helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+module Helpers
+  def linux?
+    RbConfig::CONFIG['host_os'] =~ /linux|bsd/i
+  end
+
+  def mac?
+    RbConfig::CONFIG['host_os'] =~ /darwin/i
+  end
+
+  def windows?
+    RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/i
+  end
+
+  def find_available_port
+    server = TCPServer.new('127.0.0.1', 0)
+    port = server.addr[1]
+    server.close
+    port
+  end
+end

data/lib/chromate/user_agent.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Chromate
+  class UserAgent
+    def self.call
+      new.call
+    end
+
+    attr_reader :os
+
+    def initialize
+      @os = find_os
+    end
+
+    def call
+      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36'
+    end
+
+    private
+
+    def find_os
+      case RUBY_PLATFORM
+      when /darwin/
+        'Macintosh'
+      when /linux/
+        'Linux'
+      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+        'Windows'
+      else
+        'Unknown'
+      end
+    end
+  end
+end

data/lib/chromate/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Chromate
+  VERSION = '0.0.1.pre'
+end

data/lib/chromate.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'chromate/version'
+require_relative 'chromate/browser'
+require_relative 'chromate/configuration'
+
+module Chromate
+  class << self
+    def configure
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+end