chromate-rb 0.0.1.pre

data/lib/chromate/actions/dom.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Actions
+    module Dom
+      def find_element(selector)
+        Chromate::Element.new(selector, @client)
+      end
+
+      def click_element(selector)
+        find_element(selector).click
+      end
+
+      def hover_element(selector)
+        find_element(selector).hover
+      end
+
+      def type_text(selector, text)
+        find_element(selector).type(text)
+      end
+
+      def get_text(selector)
+        find_element(selector).text
+      end
+
+      def get_property(selector, property)
+        find_element(selector).attributes[property]
+      end
+
+      def select_option(selector, option)
+        Chromate::Elements::Select.new(selector, @client).select_option(option)
+      end
+
+      def evaluate_script(script)
+        @client.send_message('Runtime.evaluate', expression: script)
+      end
+    end
+  end
+end

data/lib/chromate/actions/navigate.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Actions
+    module Navigate
+      # @param [String] url
+      # @return [self]
+      def navigate_to(url)
+        @client.send_message('Page.enable')
+        @client.send_message('Page.navigate', url: url)
+        wait_for_page_load
+      end
+
+      # @return [self]
+      def wait_for_page_load # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        page_loaded = false
+        dom_content_loaded = false
+        frame_stopped_loading = false
+
+        # Utiliser un Mutex pour la synchronisation
+        mutex = Mutex.new
+        condition = ConditionVariable.new
+
+        # S'abonner aux messages WebSocket
+        listener = proc do |message|
+          mutex.synchronize do
+            case message['method']
+            when 'Page.domContentEventFired'
+              dom_content_loaded = true
+              condition.signal if dom_content_loaded && page_loaded && frame_stopped_loading
+            when 'Page.loadEventFired'
+              page_loaded = true
+              condition.signal if dom_content_loaded && page_loaded && frame_stopped_loading
+            when 'Page.frameStoppedLoading'
+              frame_stopped_loading = true
+              condition.signal if dom_content_loaded && page_loaded && frame_stopped_loading
+            end
+          end
+        end
+
+        @client.on_message(&listener)
+
+        # Attendre les trois événements (DOMContent, Load et FrameStoppedLoading) avec un timeout
+        Timeout.timeout(15) do
+          mutex.synchronize do
+            condition.wait(mutex) until dom_content_loaded && page_loaded && frame_stopped_loading
+          end
+        end
+
+        # Nettoyer l'écouteur WebSocket
+        @client.on_message { |msg| } # Supprime tous les anciens écouteurs en ajoutant un listener vide
+
+        self
+      end
+
+      # @return [self]
+      def refresh
+        @client.send_message('Page.reload')
+        wait_for_page_load
+        self
+      end
+
+      # @return [self]
+      def go_back
+        @client.send_message('Page.goBack')
+        wait_for_page_load
+        self
+      end
+    end
+  end
+end

data/lib/chromate/actions/screenshot.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Actions
+    module Screenshot
+      def screenshot_to_file(file_path, options = {})
+        image_data = screenshot(options)
+        File.binwrite(file_path, image_data)
+        true
+      end
+
+      def screenshot_full_page(file_path, options = {})
+        metrics = @client.send_message('Page.getLayoutMetrics')
+
+        content_size = metrics['contentSize']
+        width = content_size['width'].ceil
+        height = content_size['height'].ceil
+
+        @client.send_message('Emulation.setDeviceMetricsOverride', {
+                               mobile: false,
+                               width: width,
+                               height: height,
+                               deviceScaleFactor: 1
+                             })
+
+        screenshot_to_file(file_path, options)
+
+        @client.send_message('Emulation.clearDeviceMetricsOverride')
+        true
+      end
+
+      def xvfb_screenshot(file_path)
+        display = ENV['DISPLAY'] || ':99'
+        system("xwd -root -display #{display} | convert xwd:- #{file_path}")
+      end
+
+      private
+
+      def screenshot(options = {})
+        default_options = {
+          format: 'png',
+          fromSurface: true
+        }
+
+        params = default_options.merge(options)
+
+        @client.send_message('Page.enable')
+
+        result = @client.send_message('Page.captureScreenshot', params)
+
+        image_data = result['data']
+        Base64.decode64(image_data)
+      end
+    end
+  end
+end

data/lib/chromate/browser.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+require 'securerandom'
+require 'net/http'
+require 'websocket-client-simple'
+require_relative 'helpers'
+require_relative 'client'
+require_relative 'element'
+require_relative 'hardwares'
+require_relative 'elements/select'
+require_relative 'user_agent'
+require_relative 'actions/navigate'
+require_relative 'actions/screenshot'
+require_relative 'actions/dom'
+
+module Chromate
+  class Browser
+    attr_reader :client, :options
+
+    include Helpers
+    include Actions::Navigate
+    include Actions::Screenshot
+    include Actions::Dom
+
+    def initialize(options = {})
+      @options        = config.options.merge(options)
+      @chrome_path    = @options.fetch(:chrome_path)
+      @user_data_dir  = @options.fetch(:user_data_dir, "/tmp/chromate_#{SecureRandom.hex}")
+      @headless       = @options.fetch(:headless)
+      @xfvb           = @options.fetch(:xfvb)
+      @native_control = @options.fetch(:native_control)
+      @record         = @options.fetch(:record, false)
+      @process        = nil
+      @xfvb_process   = nil
+      @record_process = nil
+      @client         = nil
+      @args           = [
+        @chrome_path,
+        "--user-data-dir=#{@user_data_dir}",
+        "--lang=#{@options[:lang] || "fr-FR"}"
+      ]
+
+      trap('INT') { stop_and_exit }
+      trap('TERM') { stop_and_exit }
+
+      at_exit { stop }
+    end
+
+    def start
+      build_args
+      @client = Client.new(self)
+      @args << "--remote-debugging-port=#{@client.port}"
+
+      start_video_recording if @record
+
+      if @xfvb
+        if ENV['DISPLAY'].nil?
+          ENV['DISPLAY'] = ':0'   if mac? # XQuartz generally uses :0 on Mac
+          ENV['DISPLAY'] = ':99'  if linux? # Xvfb generally uses :99 on Linux
+        end
+        @args << "--display=#{ENV.fetch("DISPLAY", nil)}"
+      end
+
+      @process = spawn(*@args, err: 'chrome_errors.log', out: 'chrome_output.log')
+      sleep 2
+
+      @client.start
+      self
+    end
+
+    def stop
+      Process.kill('TERM', @process)        if @process
+      Process.kill('TERM', @record_process) if @record_process
+      Process.kill('TERM', @xfvb_process)   if @xfvb_process
+      @client&.stop
+    end
+
+    def native_control?
+      @native_control
+    end
+
+    private
+
+    def start_video_recording
+      outfile = File.join(Dir.pwd, "output_video_#{Time.now.to_i}.mp4")
+      @record_process = spawn("ffmpeg -f x11grab -r 25 -s 1920x1080 -i #{ENV.fetch("DISPLAY", ":99")} -pix_fmt yuv420p -y #{outfile}")
+    end
+
+    def build_args
+      exclude_switches = config.exclude_switches || []
+      exclude_switches += @options[:exclude_switches] if @options[:exclude_switches]
+
+      @args += config.generate_arguments(**@options)
+      @args += @options[:options][:args] if @options.dig(:options, :args)
+      @args << "--user-agent=#{@options[:user_agent] || UserAgent.call}"
+      @args << "--exclude-switches=#{exclude_switches.join(",")}" if exclude_switches.any?
+
+      @args
+    end
+
+    def stop_and_exit
+      puts 'Stopping browser...'
+      stop
+      exit
+    end
+
+    def config
+      Chromate.configuration
+    end
+  end
+end

data/lib/chromate/c_logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Chromate
+  class CLogger < Logger
+    def initialize(logdev, shift_age: 0, shift_size: 1_048_576)
+      super(logdev, shift_age, shift_size)
+      self.formatter = proc do |severity, datetime, _progname, msg|
+        "[Chromate] #{datetime.strftime("%Y-%m-%d %H:%M:%S")} #{severity}: #{msg}\n"
+      end
+    end
+
+    def self.logger
+      @logger ||= new($stdout)
+    end
+
+    def self.log(message, level: :info)
+      logger.send(level, message)
+    end
+  end
+end

data/lib/chromate/client.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'websocket-client-simple'
+require 'chromate/helpers'
+
+module Chromate
+  class Client
+    include Helpers
+
+    def self.listeners
+      @@listeners ||= [] # rubocop:disable Style/ClassVars
+    end
+
+    attr_reader :port, :ws, :browser
+
+    def initialize(browser)
+      @browser = browser
+      options = browser.options
+      @port = options[:port] || find_available_port
+    end
+
+    def start
+      @ws_url = fetch_websocket_debug_url
+      @ws = WebSocket::Client::Simple.connect(@ws_url)
+      @id = 0
+      @callbacks = {}
+
+      client_self = self
+
+      @ws.on :message do |msg|
+        message = JSON.parse(msg.data)
+        client_self.handle_message(message)
+
+        Client.listeners.each do |listener|
+          listener.call(message)
+        end
+      end
+
+      @ws.on :open do
+        puts "Connexion WebSocket établie avec #{@ws_url}"
+      end
+
+      @ws.on :error do |e|
+        puts "Erreur WebSocket : #{e.message}"
+      end
+
+      @ws.on :close do |_e|
+        puts 'Connexion WebSocket fermée'
+      end
+
+      sleep 0.2
+      client_self.send_message('Target.setDiscoverTargets', { discover: true })
+      client_self
+    end
+
+    def stop
+      @ws&.close
+    end
+
+    def send_message(method, params = {})
+      @id += 1
+      message = { id: @id, method: method, params: params }
+      puts "Envoi du message : #{message}"
+
+      begin
+        @ws.send(message.to_json)
+        @callbacks[@id] = Queue.new
+        result = @callbacks[@id].pop
+        puts "Réponse reçue pour le message #{message[:id]} : #{result}"
+        result
+      rescue StandardError => e
+        puts "Erreur WebSocket lors de l'envoi du message : #{e.message}"
+        reconnect
+        retry
+      end
+    end
+
+    def reconnect
+      @ws_url = fetch_websocket_debug_url
+      @ws     = WebSocket::Client::Simple.connect(@ws_url)
+      puts 'Reconnexion WebSocket réussie'
+    end
+
+    def handle_message(message)
+      puts "Message reçu : #{message}"
+      return unless message['id'] && @callbacks[message['id']]
+
+      @callbacks[message['id']].push(message['result'])
+      @callbacks.delete(message['id'])
+    end
+
+    # Allowing different parts to subscribe to WebSocket messages
+    def on_message(&block)
+      Client.listeners << block
+    end
+
+    def fetch_websocket_debug_url
+      uri = URI("http://localhost:#{@port}/json/list")
+      response = Net::HTTP.get(uri)
+      targets = JSON.parse(response)
+
+      page_target = targets.find { |target| target['type'] == 'page' }
+
+      if page_target
+        page_target['webSocketDebuggerUrl']
+      else
+        create_new_page_target
+      end
+    end
+
+    def create_new_page_target
+      # Créer une nouvelle page
+      uri = URI("http://localhost:#{@port}/json/new")
+      response = Net::HTTP.get(uri)
+      new_target = JSON.parse(response)
+
+      new_target['webSocketDebuggerUrl']
+    end
+  end
+end

data/lib/chromate/configuration.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+require_relative 'exceptions'
+require_relative 'c_logger'
+
+module Chromate
+  class Configuration
+    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',
+      '--window-size=1920,1080', # TODO: Make this automatic
+      '--hide-crash-restore-bubble'
+    ].freeze
+    HEADLESS_ARGS = [
+      '--headless=new',
+      '--window-position=2400,2400'
+    ].freeze
+    XVFB_ARGS = [
+      '--window-position=0,0'
+    ].freeze
+    DISABLED_FEATURES = %w[
+      Translate
+      OptimizationHints
+      MediaRouter
+      DialMediaRouteProvider
+      CalculateNativeWinOcclusion
+      InterestFeedContentSuggestions
+      CertificateTransparencyComponentUpdater
+      AutofillServerCommunication
+      PrivacySandboxSettings4
+      AutomationControlled
+    ].freeze
+    EXCLUDE_SWITCHES = %w[
+      enable-automation
+    ].freeze
+
+    attr_accessor :user_data_dir, :headless, :xfvb, :native_control, :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
+      @proxy              = nil
+      @args               = [] + DEFAULT_ARGS
+      @headless_args      = [] + HEADLESS_ARGS
+      @xfvb_args          = [] + XVFB_ARGS
+      @disable_features   = [] + DISABLED_FEATURES
+      @exclude_switches   = [] + EXCLUDE_SWITCHES
+
+      @args << '--use-angle=metal' if mac?
+    end
+
+    def self.config
+      @config ||= Configuration.new
+    end
+
+    def self.configure
+      yield(config)
+    end
+
+    def config
+      self.class.config
+    end
+
+    def chrome_path
+      return ENV['CHROME_BIN'] if ENV['CHROME_BIN']
+
+      if mac?
+        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
+      elsif linux?
+        '/usr/bin/google-chrome-stable'
+      elsif windows?
+        'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe'
+      else
+        raise Exceptions::InvalidPlatformError, 'Unsupported platform'
+      end
+    end
+
+    def generate_arguments(headless: @headless, xfvb: @xfvb, proxy: @proxy, disable_features: @disable_features, **_args)
+      dynamic_args = []
+
+      dynamic_args += @headless_args  if headless
+      dynamic_args += @xfvb_args      if xfvb
+      dynamic_args << "--proxy-server=#{proxy[:host]}:#{proxy[:port]}" if proxy && proxy[:host] && proxy[:port]
+      dynamic_args << "--disable-features=#{disable_features.join(",")}" unless disable_features.empty?
+
+      @args + dynamic_args
+    end
+
+    def options
+      {
+        chrome_path: chrome_path,
+        user_data_dir: @user_data_dir,
+        headless: @headless,
+        xfvb: @xfvb,
+        native_control: @native_control,
+        args: @args,
+        headless_args: @headless_args,
+        xfvb_args: @xfvb_args,
+        exclude_switches: @exclude_switches,
+        proxy: @proxy,
+        disable_features: @disable_features
+      }
+    end
+  end
+end