bidi2pdf 0.1.3 → 0.1.5

data/lib/bidi2pdf/bidi/browser_tab.rb

@@ -3,7 +3,8 @@
 require "base64"
 
 require_relative "network_events"
-require_relative "print_parameters_validator"
+require_relative "auth_interceptor"
+require_relative "add_headers_interceptor"
 
 module Bidi2pdf
   module Bidi
@@ -20,10 +21,8 @@ module Bidi2pdf
       end
 
       def create_browser_tab
-        client.send_cmd_and_wait("browsingContext.create", {
-          type: "tab",
-          userContext: @user_context_id
-        }) do |response|
+        cmd = Bidi2pdf::Bidi::Commands::CreateTab.new(user_context_id: user_context_id)
+        client.send_cmd_and_wait(cmd) do |response|
           tab_browsing_context_id = response["result"]["context"]
 
           BrowserTab.new(client, tab_browsing_context_id, user_context_id).tap do |tab|
@@ -43,26 +42,18 @@ module Bidi2pdf
         same_site: "strict",
         ttl: 30
       )
-        expiry = Time.now.to_i + ttl
-        client.send_cmd_and_wait("storage.setCookie", {
-          cookie: {
-            name: name,
-            value: {
-              type: "string",
-              value: value
-            },
-            domain: domain,
-            path: path,
-            secure: secure,
-            httpOnly: http_only,
-            sameSite: same_site,
-            expiry: expiry
-          },
-          partition: {
-            type: "context",
-            context: browsing_context_id
-          }
-        }) do |response|
+        cmd = Bidi2pdf::Bidi::Commands::SetTabCookie.new(
+          browsing_context_id: browsing_context_id,
+          name: name,
+          value: value,
+          domain: domain,
+          path: path,
+          secure: secure,
+          http_only: http_only,
+          same_site: same_site,
+          ttl: ttl
+        )
+        client.send_cmd_and_wait(cmd) do |response|
           Bidi2pdf.logger.debug "Cookie set: #{response.inspect}"
         end
       end
@@ -71,43 +62,42 @@ module Bidi2pdf
         headers:,
         url_patterns:
       )
-        client.add_headers_interceptor(
+        AddHeadersInterceptor.new(
           context: browsing_context_id,
           url_patterns: url_patterns,
           headers: headers
-        )
+        ).tap { |interceptor| interceptor.register_with_client(client: client) }
       end
 
       def basic_auth(username:, password:, url_patterns:)
-        client.add_auth_interceptor(
+        AuthInterceptor.new(
           context: browsing_context_id,
           url_patterns: url_patterns,
-          username: username,
-          password: password
-        )
+          username: username, password: password
+        ).tap { |interceptor| interceptor.register_with_client(client: client) }
       end
 
       def open_page(url)
         client.on_event("network.responseStarted", "network.responseCompleted", "network.fetchError",
                         &network_events.method(:handle_event))
 
-        client.send_cmd_and_wait("browsingContext.navigate", {
-          url: url,
-          context: browsing_context_id,
-          wait: "complete"
-        }) do |response|
+        cmd = Bidi2pdf::Bidi::Commands::BrowsingContextNavigate.new url: url, context: browsing_context_id
+
+        client.send_cmd_and_wait(cmd) do |response|
           Bidi2pdf.logger.debug "Navigated to page url: #{url} response: #{response}"
         end
       end
 
+      def view_html_page(html_content)
+        base64_encoded = Base64.strict_encode64(html_content)
+        data_url = "data:text/html;charset=utf-8;base64,#{base64_encoded}"
+
+        open_page(data_url)
+      end
+
       def execute_script(script)
-        client.send_cmd_and_wait("script.evaluate", {
-          expression: script,
-          target: {
-            context: browsing_context_id
-          },
-          awaitPromise: true
-        }) do |response|
+        cmd = Bidi2pdf::Bidi::Commands::ScriptEvaluate.new context: browsing_context_id, expression: script
+        client.send_cmd_and_wait(cmd) do |response|
           Bidi2pdf.logger.debug "Script Result: #{response.inspect}"
 
           response["result"]
@@ -128,37 +118,41 @@ module Bidi2pdf
         @open = false
       end
 
-      # rubocop:disable Metrics/AbcSize
-      def print(outputfile, print_options: { background: true })
-        PrintParametersValidator.validate!(print_options)
-
-        cmd_params = (print_options || {}).merge(context: browsing_context_id)
+      # rubocop: disable Metrics/AbcSize, Metrics/PerceivedComplexity
+      def print(outputfile = nil, print_options: { background: true }, &block)
+        cmd = Bidi2pdf::Bidi::Commands::BrowsingContextPrint.new context: browsing_context_id, print_options: print_options
 
-        client.send_cmd_and_wait("browsingContext.print", cmd_params) do |response|
+        client.send_cmd_and_wait(cmd) do |response|
           if response["result"]
             pdf_base64 = response["result"]["data"]
 
             if outputfile
+              raise PrintError, "Folder does not exist: #{File.dirname(outputfile)}" unless File.directory?(File.dirname(outputfile))
+
               File.binwrite(outputfile, Base64.decode64(pdf_base64))
               Bidi2pdf.logger.info "PDF saved as '#{outputfile}'."
             else
               Bidi2pdf.logger.info "PDF generated successfully."
             end
 
-            return pdf_base64 unless outputfile
+            block.call(pdf_base64) if block_given?
+
+            return pdf_base64 unless outputfile || block_given?
           else
             Bidi2pdf.logger.error "Error printing: #{response}"
           end
         end
       end
 
-      # rubocop:enable Metrics/AbcSize
+      # rubocop: enable Metrics/AbcSize, Metrics/PerceivedComplexity
 
       private
 
       def close_context
-        client.send_cmd_and_wait("browsingContext.close", { context: browsing_context_id }) do |response|
-          Bidi2pdf.logger.debug "Browsing context closed: #{response}"
+        that = self
+        cmd = Bidi2pdf::Bidi::Commands::BrowsingContextClose.new context: browsing_context_id
+        client.send_cmd_and_wait(cmd) do |response|
+          Bidi2pdf.logger.info "Browsing context closed: #{that.browsing_context_id} #{response}"
         end
       end
 

data/lib/bidi2pdf/bidi/client.rb

@@ -4,10 +4,9 @@ require "json"
 require "websocket-client-simple"
 
 require_relative "web_socket_dispatcher"
-require_relative "add_headers_interceptor"
-require_relative "auth_interceptor"
 require_relative "command_manager"
 require_relative "connection_manager"
+require_relative "commands"
 
 module Bidi2pdf
   module Bidi
@@ -19,20 +18,21 @@ module Bidi2pdf
       def initialize(ws_url)
         @ws_url = ws_url
         @started = false
+        @connection_manager = ConnectionManager.new(logger: Bidi2pdf.logger)
       end
 
       def start
         return @socket if started?
 
-        @socket = WebSocket::Client::Simple.connect(ws_url)
-
-        @connection_manager = ConnectionManager.new(logger: Bidi2pdf.logger)
-        @command_manager = CommandManager.new(@socket, logger: Bidi2pdf.logger)
+        WebSocket::Client::Simple.connect(ws_url) do |socket|
+          @socket = socket
+          @command_manager = CommandManager.new(@socket, logger: Bidi2pdf.logger)
 
-        dispatcher.on_open { @connection_manager.mark_connected }
-        dispatcher.on_message { |data| handle_response_to_cmd(data) }
+          dispatcher.on_open { @connection_manager.mark_connected }
+          dispatcher.on_message { |data| handle_response_to_cmd(data) }
+          dispatcher.start_listening
+        end
 
-        dispatcher.start_listening
         @started = true
 
         @socket
@@ -42,15 +42,23 @@ module Bidi2pdf
 
       def wait_until_open(timeout: Bidi2pdf.default_timeout)
         @connection_manager.wait_until_open(timeout: timeout)
+      rescue Bidi2pdf::WebsocketError => e
+        raise Bidi2pdf::WebsocketError, "Client#start must be called within #{timeout} sec." unless started?
+
+        raise e
       end
 
-      def send_cmd(method, params = {})
-        @command_manager.send_cmd(method, params)
+      def send_cmd(cmd)
+        raise Bidi2pdf::ClientError, "Client#start must be called before" unless started?
+
+        @command_manager.send_cmd(cmd)
       end
 
-      def send_cmd_and_wait(method, params = {}, timeout: Bidi2pdf.default_timeout, &block)
-        timed("Command #{method}") do
-          @command_manager.send_cmd_and_wait(method, params, timeout: timeout, &block)
+      def send_cmd_and_wait(cmd, timeout: Bidi2pdf.default_timeout, &block)
+        raise Bidi2pdf::ClientError, "Client#start must be called before" unless started?
+
+        timed("Command #{cmd.inspect}") do
+          @command_manager.send_cmd_and_wait(cmd, timeout: timeout, &block)
         end
       end
 
@@ -64,7 +72,8 @@ module Bidi2pdf
 
       def on_event(*names, &block)
         names.each { |name| dispatcher.on_event(name, &block) }
-        send_cmd("session.subscribe", { events: names }) if names.any?
+        cmd = Bidi2pdf::Bidi::Commands::SessionSubscribe.new(events: names)
+        send_cmd(cmd) if names.any?
       end
 
       def remove_message_listener(block) = dispatcher.remove_message_listener(block)
@@ -73,28 +82,6 @@ module Bidi2pdf
         names.each { |event_name| dispatcher.remove_event_listener(event_name, block) }
       end
 
-      def add_headers_interceptor(context:, url_patterns:, headers:)
-        add_interceptor(
-          context: context,
-          url_patterns: url_patterns,
-          phase: "beforeRequestSent",
-          event: "network.beforeRequestSent",
-          interceptor_class: AddHeadersInterceptor,
-          extra_args: { headers: headers }
-        )
-      end
-
-      def add_auth_interceptor(context:, url_patterns:, username:, password:)
-        add_interceptor(
-          context: context,
-          url_patterns: url_patterns,
-          phase: "authRequired",
-          event: "network.authRequired",
-          interceptor_class: AuthInterceptor,
-          extra_args: { username: username, password: password }
-        )
-      end
-
       def close
         return unless @socket
 
@@ -120,21 +107,6 @@ module Bidi2pdf
           Bidi2pdf.logger.warn "Unknown response: #{data.inspect}"
         end
       end
-
-      def add_interceptor(context:, url_patterns:, phase:, event:, interceptor_class:, extra_args: {})
-        send_cmd_and_wait("network.addIntercept", {
-          context: context,
-          phases: [phase],
-          urlPatterns: url_patterns
-        }) do |response|
-          id = response["result"]["intercept"]
-          Bidi2pdf.logger.debug "Interceptor added: #{id}"
-
-          interceptor_class.new(id, **extra_args, client: self).tap do |interceptor|
-            on_event(event, &interceptor.method(:handle_event))
-          end
-        end
-      end
     end
   end
 end

data/lib/bidi2pdf/bidi/command_manager.rb

@@ -3,18 +3,35 @@
 module Bidi2pdf
   module Bidi
     class CommandManager
+      class << self
+        def initialize_counter
+          @id = 0
+          @id_mutex = Mutex.new
+        end
+
+        def next_id = @id_mutex.synchronize { @id += 1 }
+      end
+
+      initialize_counter
+
       def initialize(socket, logger:)
         @socket = socket
         @logger = logger
 
-        @id = 0
-        @next_id_mutex = Mutex.new
         @pending_responses = {}
+        @initiated_cmds = {}
       end
 
-      def send_cmd(method, params = {})
+      def send_cmd(cmd, store_response: false)
         id = next_id
-        payload = { id: id, method: method, params: params }
+
+        if store_response
+          init_queue_for id
+        else
+          @initiated_cmds[id] = true
+        end
+
+        payload = cmd.as_payload(id)
 
         @logger.debug "Sending command: #{redact_sensitive_fields(payload).inspect}"
         @socket.send(payload.to_json)
@@ -22,40 +39,46 @@ module Bidi2pdf
         id
       end
 
-      def send_cmd_and_wait(method, params = {}, timeout: Bidi2pdf.default_timeout)
-        id = send_cmd(method, params)
-        queue = @pending_responses[id]
+      def send_cmd_and_wait(cmd, timeout: Bidi2pdf.default_timeout)
+        id = send_cmd(cmd, store_response: true)
+        response = pop_response id, timeout: timeout
 
-        response = queue.pop(timeout: timeout)
-        raise_timeout_error(id, method, params) if response.nil?
-        raise "Error response: #{response["error"]}" if response["error"]
+        raise_timeout_error(id, cmd) if response.nil?
+        raise CmdError, "Error response: #{response["error"]} #{cmd.inspect}" if response["error"]
 
         block_given? ? yield(response) : response
       ensure
         @pending_responses.delete(id)
       end
 
-      def queue_for(id)
-        @pending_responses[id]
+      def pop_response(id, timeout:)
+        raise CmdResponseNotStoredError, "No response stored for command ID #{id} or already popped or this command was not send" unless @pending_responses.key?(id)
+
+        @pending_responses[id].pop(timeout: timeout)
+      ensure
+        @pending_responses.delete(id)
       end
 
       def handle_response(data)
-        if (id = data["id"]) && @pending_responses.key?(id)
-          @pending_responses[id]&.push(data)
-        else
-          false
+        if (id = data["id"])
+          if @pending_responses.key?(id)
+            @pending_responses[id]&.push(data)
+            return true
+          elsif @initiated_cmds.key?(id)
+            @logger.error "Received error: #{data["error"]} for cmd: #{id}" if data["error"]
+
+            return @initiated_cmds.delete(id)
+          end
         end
+
+        false
       end
 
       private
 
-      def next_id
-        @next_id_mutex.synchronize do
-          @id += 1
-          @pending_responses[@id] = Thread::Queue.new
-          @id
-        end
-      end
+      def init_queue_for(id) = @pending_responses[id] = Thread::Queue.new
+
+      def next_id = self.class.next_id
 
       def redact_sensitive_fields(obj, sensitive_keys = %w[value token password authorization username])
         case obj
@@ -71,11 +94,10 @@ module Bidi2pdf
         end
       end
 
-      def raise_timeout_error(id, method, params)
-        # rubocop:disable Layout/LineLength
-        @logger.error "Timeout waiting for response to command #{id}, cmd: #{method}, params: #{redact_sensitive_fields(params).inspect}"
-        # rubocop:enable Layout/LineLength
-        raise "Timeout waiting for response to command ID #{id}"
+      def raise_timeout_error(id, cmd)
+        @logger.error "Timeout waiting for response to command #{id}, cmd: #{cmd.inspect}"
+
+        raise CmdTimeoutError, "Timeout waiting for response to command ID #{id}"
       end
     end
   end

data/lib/bidi2pdf/bidi/commands/add_intercept.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class AddIntercept
+        include Base
+
+        BEFORE_REQUEST = "beforeRequestSent"
+        RESPONSE_STARTED = "responseStarted"
+        AUTH_REQUIRED = "authRequired"
+
+        def initialize(context:, phases:, url_patterns:)
+          @context = context
+          @phases = phases
+          @url_patterns = url_patterns
+
+          validate_phases!
+        end
+
+        def method_name
+          "network.addIntercept"
+        end
+
+        def params
+          {
+            context: @context,
+            phases: @phases,
+            urlPatterns: @url_patterns
+          }.compact
+        end
+
+        def validate_phases!
+          valid_phases = [BEFORE_REQUEST, RESPONSE_STARTED, AUTH_REQUIRED]
+
+          raise ArgumentError, "Unsupported phase(s): #{@phases}" unless @phases.all? { |phase| valid_phases.include?(phase) }
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands/base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      module Base
+        def method_name = raise(NotImplementedError, "method_name must be implemented in subclass")
+
+        def params = {}
+
+        def as_payload(id)
+          {
+            id: id,
+            method: method_name,
+            params: params
+          }
+        end
+
+        # rubocop: disable Metrics/AbcSize
+        def ==(other)
+          return false unless other.respond_to?(:method_name) && other.respond_to?(:params)
+
+          return false unless method_name == other.method_name
+
+          return false unless params.keys.sort == other.params.keys.sort
+
+          params.all? { |key, value| other.params.key?(key) && value == other.params[key] }
+        end
+
+        # rubocop: enable Metrics/AbcSize
+
+        # Hash equality comparison
+        def eql?(other)
+          return false unless other.is_a?(Bidi2pdf::Bidi::Commands::Base)
+
+          self == other
+        end
+
+        def hash
+          [method_name, params].hash
+        end
+
+        def inspect
+          attributes = redact_sensitive_fields({ method_name: method_name, params: params })
+
+          "#<#{self.class}:#{object_id} #{attributes}>"
+        end
+
+        private
+
+        def redact_sensitive_fields(obj, sensitive_keys = %w[value token password authorization username])
+          case obj
+          when Hash
+            obj.transform_values.with_index do |v, idx|
+              k = obj.keys[idx]
+              sensitive_keys.include?(k.to_s.downcase) ? "[REDACTED]" : redact_sensitive_fields(v, sensitive_keys)
+            end
+          when Array
+            obj.map { |item| redact_sensitive_fields(item, sensitive_keys) }
+          else
+            obj
+          end
+        end
+
+        def raise_timeout_error(id, method, params)
+          @logger.error "Timeout waiting for response to command #{id}, cmd: #{method}, params: #{redact_sensitive_fields(params).inspect}"
+
+          raise CmdTimeoutError, "Timeout waiting for response to command ID #{id}"
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands/browser_close.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class BrowserClose
+        include Base
+
+        def method_name
+          "browser.close"
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands/browser_create_user_context.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class BrowserCreateUserContext
+        include Base
+
+        def method_name
+          "browser.createUserContext"
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands/browsing_context_close.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class BrowsingContextClose
+        include Base
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def params
+          {
+            context: @context
+          }
+        end
+
+        def method_name
+          "browsingContext.close"
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands/browsing_context_navigate.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class BrowsingContextNavigate
+        include Base
+
+        def initialize(url:,
+                       context:,
+                       wait: "complete")
+          @url = url
+          @context = context
+          @wait = wait
+        end
+
+        def params
+          {
+            url: @url,
+            context: @context,
+            wait: @wait
+          }
+        end
+
+        def method_name
+          "browsingContext.navigate"
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands/browsing_context_print.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "print_parameters_validator"
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class BrowsingContextPrint
+        include Base
+
+        def initialize(context:, print_options:)
+          @context = context
+          @print_options = print_options || { background: true }
+
+          PrintParametersValidator.validate!(@print_options)
+        end
+
+        def params
+          @print_options.merge(context: @context)
+        end
+
+        def method_name
+          "browsingContext.print"
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands/cancel_auth.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class CancelAuth
+        include Base
+
+        def initialize(request:)
+          @request = request
+        end
+
+        def params
+          {
+            request: @request,
+            action: "cancel"
+          }
+        end
+
+        def method_name
+          "network.continueWithAuth"
+        end
+      end
+    end
+  end
+end