bidi2pdf-rails 0.0.1.pre.alpha → 0.1.0

data/lib/bidi2pdf_rails/config.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "configurable"
+
+module Bidi2pdfRails
+  class Config
+    include Bidi2pdfRails::Configurable
+
+    CONFIG_OPTIONS = {
+      general_options: {
+        name: "General Options",
+        ask: "Configure general options? (y/n)",
+        options: [
+          { name: :logger, desc: "The logger", default: -> { Rails.logger || ActiveSupport::TaggedLogging.new(Logger.new(nil)) }, default_as_str: "Rails.logger", ask: false, color: :yellow },
+          { name: :verbosity, desc: "How verbose to be", default: Bidi2pdf::VerboseLogger::VERBOSITY_LEVELS.keys.sort_by { |k| Bidi2pdf::VerboseLogger::VERBOSITY_LEVELS[k] }.first.to_s, limited_to: Bidi2pdf::VerboseLogger::VERBOSITY_LEVELS.keys.sort_by { |k| Bidi2pdf::VerboseLogger::VERBOSITY_LEVELS[k] }.map(&:to_s), ask: true, color: :yellow },
+          { name: :headless, desc: "Run Chrome in headless mode", default: -> { !Rails.env.development? }, default_as_str: "!Rails.env.development?", ask: true, color: :green },
+          { name: :wait_for_network_idle, desc: "Wait for network idle", default: true, ask: true, color: :green },
+          { name: :wait_for_page_loaded, desc: "Wait for page loaded", default: false, ask: true, color: :green },
+          { name: :wait_for_page_check_script, desc: "Wait for page check script", default: nil, ask: false },
+          { name: :notification_service, desc: "Notification service", default: -> { ActiveSupport::Notifications }, default_as_str: "-> { ActiveSupport::Notifications }", ask: false },
+          { name: :default_timeout, desc: "Default timeout for various Bidi commands", default: 10, ask: true, color: :yellow },
+          { name: :chrome_session_args, desc: "Chrome session arguments", default: Bidi2pdf::Bidi::Session::DEFAULT_CHROME_ARGS, ask: false }
+        ]
+      },
+
+      chromedriver_settings: {
+        name: "Chromedriver Settings (when chromedriver run within your app)",
+        ask: "Configure chromedriver settings? (y/n)",
+        options: [
+          { name: :install_dir, desc: "Chromedriver install directory", default: nil, ask: false, color: :yellow },
+          { name: :port, desc: "Chromedriver port", default: 0, ask: true, color: :yellow }
+        ]
+      },
+
+      proxy_settings: {
+        name: "Proxy Settings",
+        ask: "Use a proxy server? (y/n)",
+        options: [
+          { name: :addr, desc: "Proxy address (e.g., 127.0.0.1)", default: nil, ask: true, color: :yellow },
+          { name: :port, desc: "Proxy port (e.g., 8080)", default: nil, ask: true, color: :yellow },
+          { name: :user, desc: "Proxy user", default: nil, ask: true, color: :yellow },
+          {
+            name: :pass,
+            desc: "Proxy password",
+            default: -> { -> { Rails.application.credentials.dig("bidi2pdf_rails", "proxy_pass") } },
+            default_as_str: "-> { Rails.application.credentials.dig('bidi2pdf_rails', 'proxy_pass') }",
+            secret: true,
+            ask: true,
+            color: :yellow
+          }
+        ]
+      },
+
+      pdf_settings: {
+        name: "PDF Settings",
+        ask: "Configure custom PDF settings? (y/n)",
+        options: [
+          { name: :orientation, desc: "PDF orientation (portrait/landscape)", default: "portrait", limited_to: %w[portrait landscape], ask: true },
+          { name: :margins, desc: "Configure PDF margins?", default: false, ask: true, color: :green },
+          { name: :margin_top, desc: "PDF margin top (cm)", default: 2.5, ask: true, color: :yellow },
+          { name: :margin_bottom, desc: "PDF margin bottom (cm)", default: 2, ask: true, color: :yellow },
+          { name: :margin_left, desc: "PDF margin left (cm)", default: 2, ask: true, color: :yellow },
+          { name: :margin_right, desc: "PDF margin right (cm)", default: 2, ask: true, color: :yellow },
+          { name: :page_format, desc: "PDF page format (e.g., A4)", default: nil, limited_to: Bidi2pdf::PAPER_FORMATS_CM.keys.map(&:to_s), ask: true },
+          { name: :page_width, desc: "PDF page width (cm, not needed when format is specified)", default: Bidi2pdf::PAPER_FORMATS_CM[:a4][:width], ask: true, color: :yellow },
+          { name: :page_height, desc: "PDF page height (cm, not needed when format is specified)", default: Bidi2pdf::PAPER_FORMATS_CM[:a4][:height], ask: true, color: :yellow },
+          { name: :print_background, desc: "Print background graphics?", default: true, ask: true, color: :green },
+          { name: :scale, desc: "PDF scale (e.g., 1.0)", default: 1.0, ask: true, color: :yellow },
+          { name: :shrink_to_fit, desc: "Shrink to fit?", default: false, ask: true, color: :green }
+        ]
+      },
+
+      render_remote_settings: {
+        name: "Remote URL Settings",
+        ask: false,
+        options: [
+          { name: :browser_url, desc: "Remote browser URL (e.g. http://localhost:3001/sesion)", default: nil, ask: true, color: :yellow },
+          { name: :basic_auth_user, desc: "Basic auth user", default: nil },
+          { name: :basic_auth_pass, desc: "Basic auth password", default: nil, default_as_str: "-> { Rails.application.credentials.dig('bidi2pdf_rails', 'basic_auth_pass') }", secret: true },
+          { name: :headers, desc: "Headers to be send when allong an url", default: {}, default_as_str: '{"X-API-INFO" => "my info"}' },
+          { name: :cookies, desc: "Cookies to be send when alling an url", default: {}, default_as_str: '{"session_id" => "my session"}' }
+        ]
+      }
+
+    }.freeze
+
+    configure_with(CONFIG_OPTIONS)
+
+    def initialize
+      reset_to_defaults!
+    end
+
+    def pdf_settings_for_bidi_cmd(overrides = {})
+      overrides ||= {}
+      opts = {}
+
+      opts[:background] = pdf_settings.print_background_value
+      opts[:orientation] = pdf_settings.orientation_value
+      opts[:scale] = pdf_settings.scale_value
+      opts[:shrinkToFit] = pdf_settings.shrink_to_fit_value
+
+      # Margins
+      margins = {
+        top: pdf_settings.margin_top_value,
+        bottom: pdf_settings.margin_bottom_value,
+        left: pdf_settings.margin_left_value,
+        right: pdf_settings.margin_right_value
+      }.compact
+
+      opts[:margin] = margins unless margins.empty?
+
+      # Page size
+      page = {
+        width: pdf_settings.page_width_value,
+        height: pdf_settings.page_height_value,
+        format: pdf_settings.page_format_value
+      }.compact
+
+      page = overrides[:page].compact if overrides[:page]&.compact.present?
+      page = { format: page[:format] } if page[:format]
+
+      opts[:page] = page unless page.empty?
+
+      opts.deep_merge(overrides).compact
+    end
+
+    def validate_print_options!
+      validator = Bidi2pdf::Bidi::Commands::PrintParametersValidator.new(pdf_settings_for_bidi_cmd)
+
+      validator.validate!
+    end
+  end
+end

data/lib/bidi2pdf_rails/configurable.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Bidi2pdfRails
+  module Configurable
+    extend ActiveSupport::Concern
+    included do
+      include Singleton
+    end
+
+    class BaseNestedConfig
+      def initialize(option_defs)
+        @__options = option_defs
+        define_accessors!
+        reset_to_defaults!
+      end
+
+      def define_accessors!
+        @__options.each do |opt|
+          name = opt[:name]
+          unless respond_to?(name)
+            define_singleton_method(name) { instance_variable_get("@#{name}") }
+            define_singleton_method("#{name}=") { |v| instance_variable_set("@#{name}", v) }
+
+            define_singleton_method("#{name}_value") do |*args|
+              value = send("#{name}")
+              value.respond_to?(:call) ? value.call(*args) : value
+            end
+          end
+        end
+      end
+
+      def reset_to_defaults!
+        @__options.each do |opt|
+          default = opt[:default]
+          value = default
+          send("#{opt[:name]}=", value)
+        end
+      end
+
+      def config_options
+        @__options
+      end
+
+      def configure
+        yield self if block_given?
+      end
+
+      def to_h
+        @__options.to_h do |opt|
+          [opt[:name], send(opt[:name])]
+        end
+      end
+
+      def inspect
+        "#<#{self.class.name || "ConfigSection"} #{to_h.inspect}>"
+      end
+    end
+
+    def configure
+      yield self if block_given?
+    end
+
+    class_methods do
+      def configure_with(grouped_options)
+        @config_groups = grouped_options
+
+        grouped_options.each do |group_key, group_data|
+          group_class = Class.new(BaseNestedConfig)
+
+          define_method(group_key) do
+            ivar = "@#{group_key}"
+            instance_variable_get(ivar) || instance_variable_set(ivar, group_class.new(group_data[:options]))
+          end
+
+          define_method("#{group_key}=") do |val|
+            raise ArgumentError, "Use individual accessors, not direct assignment to config groups"
+          end
+        end
+
+        define_method(:reset_to_defaults!) do
+          grouped_options.each_key do |group_key|
+            section = send(group_key)
+            section.reset_to_defaults!
+          end
+        end
+
+        define_method(:config_groups) do
+          grouped_options
+        end
+
+        define_method(:to_h) do
+          grouped_options.keys.to_h do |group_key|
+            section = send(group_key)
+            [group_key, section.to_h]
+          end
+        end
+
+        define_method(:inspect) do
+          "#<#{self.class.name} #{to_h.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf_rails/main_log_subscriber.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Bidi2pdfRails
+  class MainLogSubscriber < ActiveSupport::LogSubscriber
+    @silenced_events = []
+
+    class << self
+      attr_accessor :silenced_events
+
+      def silence(event)
+        self.silenced_events << event
+      end
+
+      def silenced?(event)
+        self.silenced_events.any? { |silenced_event| silenced_event === event }
+      end
+    end
+
+    include Bidi2pdf::Notifications::LoggingSubscriberActions
+
+    def handle_printing(event)
+      logger.info "Page rendered and printed: #{event.duration.round(1)}ms"
+    end
+
+    def logger
+      Bidi2pdf::VerboseLogger.new(super.tagged("bidi2pdf_rails"), Bidi2pdfRails.config.general_options.verbosity_value)
+    end
+
+    def silenced?(event)
+      MainLogSubscriber.silenced?(event) || super(event)
+    end
+  end
+end

data/lib/bidi2pdf_rails/network_log_subscriber.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bidi2pdf/bidi/network_event_formatters/network_event_console_formatter"
+
+module Bidi2pdfRails
+  class NetworkLogSubscriber < ActiveSupport::LogSubscriber
+    def network_event_received(event)
+      payload = event.payload
+
+      return if payload[:method] == "network.responseStarted" || payload[:method] == "network.beforeRequestSent"
+
+      logger.tagged("bidi2pdf_rails", "network") do |tagged_logger|
+        verbose_logger = Bidi2pdf::VerboseLogger.new(tagged_logger, Bidi2pdfRails.config.general_options.verbosity_value)
+        formatter = Bidi2pdf::Bidi::NetworkEventFormatters::NetworkEventConsoleFormatter.new(logger: verbose_logger)
+
+        formatter.log [payload[:event]]
+      end
+    end
+  end
+end

data/lib/bidi2pdf_rails/railtie.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
+require "rails/railtie"
+
+require_relative "services/html_renderer"
+require_relative "services/pdf_renderer"
+require_relative "services/pdf_browser_session"
+require_relative "services/url_to_pdf_converter"
+require_relative "services/html_to_pdf_converter"
+
 module Bidi2pdfRails
   class Railtie < ::Rails::Railtie
     initializer "bidi2pdf_rails.add_mime_type" do
@@ -9,7 +17,8 @@ module Bidi2pdfRails
     initializer "bidi2pdf_rails.initialize_chromedriver_manager", after: :load_config_initializers do
       Bidi2pdfRails.apply_bidi2pdf_config
 
-      Rails.application.config.after_initialize do
+      # defer the initialization of the ChromedriverManager to the ActionController::Base class load event
+      ActiveSupport.on_load(:action_controller_base) do
         ChromedriverManagerSingleton.initialize_manager
       end
     end
@@ -23,56 +32,14 @@ module Bidi2pdfRails
 
     initializer "bidi2pdf_rails.add_pdf_renderer" do
       ActionController::Renderers.add :pdf do |filename, options|
-        pdf_data = ""
         options = options.dup
 
-        original_asset_host = ActionController::Base.asset_host
-
-        if options[:asset_host]
-          ActionController::Base.asset_host = options[:asset_host]
-        elsif !Rails.application.config.action_controller.asset_host
-          # Use request base URL as fallback if no asset host configured
-          ActionController::Base.asset_host = request.base_url
-        end
-
-        html = render_to_string(options.merge(formats: [ :html ]))
-
-        Bidi2pdf.default_timeout = 30
-
-        # without a thread, the app will be blocked in dev mode
-        thread = Thread.new {
-          Rails.application.executor.wrap do
-            # subscriptions in other threads will not be inherited
-            Bidi2pdfRails::LogSubscriber.attach_to "bidi2pdf", inherit_all: true
-
-            browser = ChromedriverManagerSingleton.session.browser
-            context = browser.create_user_context
-            window = context.create_browser_window
-            tab = window.create_browser_tab
+        pdf_content = Services::PdfRenderer.new(filename, options, self).render_pdf
 
-            tab.render_html_content html
-
-            tab.wait_until_network_idle
-
-            tab.wait_until_page_loaded
-
-            pdf_data = tab.print
-          ensure
-            tab&.close
-            window&.close
-            context&.close
-          end
-        }
-
-        thread.join
-
-        send_data Base64.decode64(pdf_data),
+        send_data pdf_content,
                   type: Mime[:pdf],
                   filename: "#{filename}.pdf",
                   disposition: options.fetch(:disposition, "inline")
-      ensure
-
-        ActionController::Base.asset_host = original_asset_host
       end
     end
   end

data/lib/bidi2pdf_rails/services/html_renderer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Bidi2pdfRails
+  module Services
+    # app/services/html_renderer.rb
+    class HtmlRenderer
+      def initialize(controller, options)
+        @controller = controller
+        @options = options.dup
+      end
+
+      def render
+        with_overridden_asset_host { @controller.render_to_string(@options.merge(formats: [:html])) }
+      end
+
+      private
+
+      def with_overridden_asset_host
+        original_asset_host = ActionController::Base.asset_host
+
+        if @options[:asset_host]
+          ActionController::Base.asset_host = @options[:asset_host]
+        elsif !Rails.application.config.action_controller.asset_host
+          ActionController::Base.asset_host = @controller.request.base_url
+        end
+
+        yield
+      ensure
+        ActionController::Base.asset_host = original_asset_host
+      end
+    end
+  end
+end

data/lib/bidi2pdf_rails/services/html_to_pdf_converter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Bidi2pdfRails
+  module Services
+    class HtmlToPdfConverter
+      include PdfBrowserSession
+
+      def initialize(html, print_options: {}, wait_for_network_idle: true, wait_for_page_loaded: true, wait_for_page_check_script: nil)
+        @html = html
+        @print_options = print_options
+        @wait_for_network_idle = wait_for_network_idle
+        @wait_for_page_loaded = wait_for_page_loaded
+        @wait_for_page_check_script = wait_for_page_check_script
+      end
+
+      def generate
+        run_browser_session
+      end
+
+      private
+
+      def prepare_tab(tab)
+        tab.render_html_content(@html)
+        wait_for_tab(tab)
+      end
+    end
+  end
+end

data/lib/bidi2pdf_rails/services/pdf_browser_session.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Bidi2pdfRails
+  module Services
+    module PdfBrowserSession
+      def run_browser_session
+        pdf_data = nil
+
+        thread = Thread.new do
+          Rails.application.executor.wrap do
+            browser = ChromedriverManagerSingleton.session.browser
+            context = browser.create_user_context
+            window = context.create_browser_window
+            tab = window.create_browser_tab
+
+            begin
+              prepare_tab(tab)
+              pdf_data = tab.print(print_options: @print_options)
+            ensure
+              tab&.close
+              window&.close
+              context&.close
+            end
+          end
+        end
+
+        thread.join
+        Base64.decode64(pdf_data)
+      end
+
+      private
+
+      def wait_for_tab(tab)
+        tab.wait_until_network_idle if @wait_for_network_idle
+        tab.wait_until_page_loaded(check_script: @wait_for_page_check_script) if @wait_for_page_loaded
+      end
+    end
+  end
+end

data/lib/bidi2pdf_rails/services/pdf_renderer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Bidi2pdfRails
+  module Services
+    # PdfRenderer is responsible for rendering a Rails view into a PDF using headless Chrome.
+    #
+    # It accepts a mix of HTML rendering options (passed to `render_to_string`) and PDF generation options.
+    #
+    # @example Basic usage
+    #   renderer = Bidi2pdfRails::Services::PdfRenderer.new("invoice", { template: "invoices/show" }, controller)
+    #   renderer.render_pdf
+    #
+    # @param filename [String] the base filename for the generated PDF (used for download naming)
+    # @param options [Hash] rendering options including both HTML and PDF-specific options
+    # @option options [String] :template The template to render (or other render_to_string keys like :partial, :layout, etc.)
+    # @option options [String] :asset_host Optional asset host override
+    # @option options [Hash] :print_options Options passed to the Chrome PDF print API
+    # @option options [Boolean] :wait_for_network_idle Wait for network to go idle before generating PDF (default: config default)
+    # @option options [Boolean] :wait_for_page_loaded Wait for page load event before generating PDF (default: config default)
+    # @option options [String] :wait_for_page_check_script JavaScript condition to wait for before generating PDF
+    #
+    class PdfRenderer
+      PDF_OPTIONS = %i[
+        print_options
+        asset_host
+        wait_for_network_idle
+        wait_for_page_loaded
+        wait_for_page_check_script
+        html
+      ].freeze
+
+      PRINT_URL_OPTIONS = %i[
+        url
+        auth
+        headers
+        cookies
+      ].freeze
+
+      def initialize(filename, options, controller)
+        @filename = filename
+        @pdf_options = options.slice(*PDF_OPTIONS)
+        @print_url_options = options.slice(*PRINT_URL_OPTIONS)
+        @html_options = options.except(*(PDF_OPTIONS + PRINT_URL_OPTIONS))
+        @controller = controller
+      end
+
+      def render_pdf
+        ActiveSupport::Notifications.instrument("handle_printing.bidi2pdf_rails") do
+          print_options = Bidi2pdfRails.config.pdf_settings_for_bidi_cmd(@pdf_options[:print_options] || {})
+          wait_for_network_idle = @pdf_options.fetch(:wait_for_network_idle, Bidi2pdfRails.config.general_options.wait_for_network_idle_value)
+          wait_for_page_loaded = @pdf_options.fetch(:wait_for_page_loaded, Bidi2pdfRails.config.general_options.wait_for_page_loaded_value)
+          wait_for_page_check_script = @pdf_options.fetch(:wait_for_page_check_script, Bidi2pdfRails.config.general_options.wait_for_page_check_script_value)
+
+          if @print_url_options[:url]
+            headers = @print_url_options[:headers] || Bidi2pdfRails.config.render_remote_settings.headers_value(@controller)
+            cookies = @print_url_options[:cookies] || Bidi2pdfRails.config.render_remote_settings.cookies_value(@controller)
+            auth = @print_url_options[:auth] || { username: Bidi2pdfRails.config.render_remote_settings.basic_auth_user_value(@controller), password: Bidi2pdfRails.config.render_remote_settings.basic_auth_pass_value(@controller) }
+
+            UrlToPdfConverter.new(@print_url_options[:url],
+                                  headers: headers,
+                                  cookies: cookies,
+                                  auth: auth,
+                                  print_options: print_options,
+                                  wait_for_network_idle: wait_for_network_idle,
+                                  wait_for_page_loaded: wait_for_page_loaded,
+                                  wait_for_page_check_script: wait_for_page_check_script
+            ).generate
+          else
+            html = @html_options.fetch(:inline, HtmlRenderer.new(@controller, @html_options).render)
+
+            HtmlToPdfConverter.new(html,
+                                   print_options: print_options,
+                                   wait_for_network_idle: wait_for_network_idle,
+                                   wait_for_page_loaded: wait_for_page_loaded,
+                                   wait_for_page_check_script: wait_for_page_check_script
+            ).generate
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf_rails/services/url_to_pdf_converter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Bidi2pdfRails
+  module Services
+    class UrlToPdfConverter
+      include PdfBrowserSession
+
+      def initialize(url, headers: {}, cookies: {}, auth: {}, print_options: {}, wait_for_network_idle: true, wait_for_page_loaded: true, wait_for_page_check_script: nil)
+        @url = url
+        @headers = headers || {}
+        @cookies = cookies || {}
+        @auth = auth || {}
+        @print_options = print_options
+        @wait_for_network_idle = wait_for_network_idle
+        @wait_for_page_loaded = wait_for_page_loaded
+        @wait_for_page_check_script = wait_for_page_check_script
+      end
+
+      def generate
+        run_browser_session
+      end
+
+      private
+
+      def prepare_tab(tab)
+        add_headers(tab)
+        add_basic_auth(tab)
+        add_cookies(tab)
+
+        tab.navigate_to(@url)
+        wait_for_tab(tab)
+      end
+
+      def add_cookies(tab)
+        @cookies.each do |name, value|
+          tab.set_cookie(
+            name: name,
+            value: value,
+            domain: domain,
+            secure: uri.scheme == "https"
+          )
+        end
+      end
+
+      def add_headers(tab)
+        @headers.each do |name, value|
+          tab.add_headers(
+            url_patterns: url_patterns,
+            headers: [{ name: name, value: value }]
+          )
+        end
+      end
+
+      def add_basic_auth(tab)
+        return unless @auth[:username] && @auth[:password]
+
+        tab.basic_auth(
+          url_patterns: url_patterns,
+          username: @auth[:username],
+          password: @auth[:password]
+        )
+      end
+
+      def uri
+        @uri ||= URI(@url)
+      end
+
+      def domain
+        uri.host
+      end
+
+      def url_patterns
+        [{
+           type: "pattern",
+           protocol: uri.scheme,
+           hostname: uri.host,
+           port: uri.port.to_s
+         }]
+      end
+    end
+  end
+end

data/lib/bidi2pdf_rails/version.rb

@@ -1,3 +1,3 @@
 module Bidi2pdfRails
-    VERSION = "0.0.1.pre.alpha"
+  VERSION = "0.1.0"
 end