bidi2pdf-rails 0.0.1.pre.alpha → 0.1.1

data/lib/bidi2pdf_rails/services/pdf_browser_session.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Bidi2pdfRails
+  module Services
+    module PdfBrowserSession
+      def run_browser_session
+        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)
+              tab.print(print_options: @print_options)
+            ensure
+              tab&.close
+              window&.close
+              context&.close
+            end
+          end
+        end
+
+        pdf_data = thread.value
+
+        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_injection.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bidi2pdfRails
+  module Services
+    module PdfInjection
+      def inject_custom_css(tab, custom_css, custom_css_url)
+        return unless custom_css || custom_css_url
+
+        if custom_css
+          tab.inject_style(url: nil, content: custom_css, id: nil)
+        end
+
+        if custom_css_url
+          tab.inject_style(url: custom_css_url, content: nil, id: nil)
+        end
+      end
+
+      def inject_custom_js(tab, custom_js, custom_js_url)
+        return unless custom_js || custom_js_url
+
+        if custom_js
+          tab.inject_script(url: nil, content: custom_js, id: nil)
+        end
+
+        if custom_js_url
+          tab.inject_script(url: custom_js_url, content: nil, id: nil)
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf_rails/services/pdf_renderer.rb

@@ -0,0 +1,94 @@
+# 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)
+          custom_css = @pdf_options.fetch(:custom_css, Bidi2pdfRails.config.pdf_settings.custom_css_value(@controller))
+          custom_css_url = @pdf_options.fetch(:custom_css_url, Bidi2pdfRails.config.pdf_settings.custom_css_url_value(@controller))
+          custom_js = @pdf_options.fetch(:custom_js, Bidi2pdfRails.config.pdf_settings.custom_js_value(@controller))
+          custom_js_url = @pdf_options.fetch(:custom_js_url, Bidi2pdfRails.config.pdf_settings.custom_js_url_value(@controller))
+
+          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,
+                                  custom_css: custom_css,
+                                  custom_css_url: custom_css_url,
+                                  custom_js: custom_js,
+                                  custom_js_url: custom_js_url,
+            ).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,
+                                   custom_css: custom_css,
+                                   custom_css_url: custom_css_url,
+                                   custom_js: custom_js,
+                                   custom_js_url: custom_js_url,
+            ).generate
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf_rails/services/url_to_pdf_converter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Bidi2pdfRails
+  module Services
+    class UrlToPdfConverter
+      include PdfBrowserSession
+      include PdfInjection
+
+      def initialize(url, headers: {}, cookies: {}, auth: {}, print_options: {}, wait_for_network_idle: true, wait_for_page_loaded: true, wait_for_page_check_script: nil, custom_css: nil, custom_css_url: nil, custom_js: nil, custom_js_url: 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
+        @custom_css = custom_css
+        @custom_css_url = custom_css_url
+        @custom_js = custom_js
+        @custom_js_url = custom_js_url
+      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)
+
+        inject_custom_css(tab, @custom_css, @custom_css_url)
+        inject_custom_js(tab, @custom_js, @custom_js_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.1"
 end

data/lib/bidi2pdf_rails.rb

@@ -1,87 +1,70 @@
 # frozen_string_literal: true
 
 require "bidi2pdf"
-require "bidi2pdf_rails/version"
-require "bidi2pdf_rails/railtie"
-require "bidi2pdf_rails/chromedriver_manager_singleton"
-require "bidi2pdf_rails/log_subscriber"
+require "bidi2pdf/bidi/commands/print_parameters_validator"
+require_relative "bidi2pdf_rails/version"
+require_relative "bidi2pdf_rails/config"
+require_relative "bidi2pdf_rails/railtie"
+require_relative "bidi2pdf_rails/chromedriver_manager_singleton"
+require_relative "bidi2pdf_rails/main_log_subscriber"
+require_relative "bidi2pdf_rails/browser_console_log_subscriber"
+require_relative "bidi2pdf_rails/network_log_subscriber"
 
 module Bidi2pdfRails
   class << self
-    attr_accessor :logger, :notification_service, :verbosity, :default_timeout, :log_network_events, :log_browser_console, :remote_browser_url, :cookies,
-                  :headers, :auth, :headless, :chromedriver_port, :chrome_session_args,
-                  :proxy_addr, :proxy_port, :proxy_user, :proxy_pass, :install_dir,
-                  :viewport_width, :viewport_height,
-                  :pdf_margin_top, :pdf_margin_bottom, :pdf_margin_left, :pdf_margin_right,
-                  :pdf_scale, :pdf_print_background, :pdf_format, :pdf_orientation, :verbosity
+    def config
+      Config.instance
+    end
 
     # Allow configuration through a block
     def configure
-      yield self if block_given?
+      yield config if block_given?
 
-      apply_bidi2pdf_config
-    end
+      config.validate_print_options!
 
-    def apply_bidi2pdf_config
-      # Allow configuration through a block
-      Bidi2pdf.configure do |config|
-        config.notification_service = notification_service
+      apply_bidi2pdf_config config
+    end
 
-        config.logger = logger.tagged("bidi2pdf")
-        config.default_timeout = default_timeout
+    def apply_bidi2pdf_config(config = Config.instance)
+      Bidi2pdf.configure do |bidi2pdf_config|
+        bidi2pdf_config.notification_service = config.general_options.notification_service_value
 
-        if log_network_events
-          config.network_events_logger = logger.tagged("bidi2pdf", "network")
-        else
-          config.network_events_logger = Logger.new(nil) # Disable network events logging
-        end
+        bidi2pdf_config.logger = config.general_options.logger_value&.tagged("bidi2pdf")
+        bidi2pdf_config.default_timeout = config.general_options.default_timeout_value
 
-        if log_browser_console
-          config.browser_console_logger = logger.tagged("bidi2pdf", "browser_console")
-        else
-          config.browser_console_logger = Logger.new(nil) # Disable browser console logging
-        end
+        bidi2pdf_config.network_events_logger = Logger.new(nil)
+        bidi2pdf_config.browser_console_logger = Logger.new(nil)
 
-        config.enable_default_logging_subscriber = false
+        bidi2pdf_config.enable_default_logging_subscriber = false
       end
 
-      Chromedriver::Binary.configure do |config|
-        config.logger = logger
+      Chromedriver::Binary.configure do |chromedriver_config|
+        chromedriver_config.logger = config.general_options.logger_value&.tagged("bidi2pdf")
 
-        config.proxy_addr = proxy_addr
-        config.proxy_port = proxy_port
-        config.proxy_user = proxy_user
-        config.proxy_pass = proxy_pass
+        chromedriver_config.proxy_addr = config.proxy_settings.addr_value
+        chromedriver_config.proxy_port = config.proxy_settings.port_value
+        chromedriver_config.proxy_user = config.proxy_settings.user_value
+        chromedriver_config.proxy_pass = config.proxy_settings.pass_value
 
-        config.install_dir = install_dir
+        chromedriver_config.install_dir = config.chromedriver_settings.install_dir_value
       end
     end
 
-    def reset_to_defaults!
-      @logger = nil
-      @default_timeout = 10
-      @log_network_events = false
-      @log_browser_console = true
-      @verbosity = 0
-      @remote_browser_url = nil
-      @cookies = {}
-      @headers = {}
-      @auth = nil
-      @headless = !Rails.env.development?
-      @chromedriver_port = 0
-      @chrome_session_args = Bidi2pdf::Bidi::Session::DEFAULT_CHROME_ARGS
-
-      @proxy_addr = nil
-      @proxy_port = nil
-      @proxy_user = nil
-      @proxy_pass = nil
-      @install_dir = nil
+    def use_local_chromedriver?
+      !use_remote_browser?
+    end
+
+    def use_remote_browser?
+      config.render_remote_settings.browser_url_value.present?
     end
 
     def logger
-      @logger ||= Rails.logger # lazy load the logger, after it exists
+      config.general_options.logger_value&.tagged("bidi2pdf-rails")
     end
   end
 
-  self.reset_to_defaults!
+  that = self
+  ActiveSupport.on_load(:action_controller_base, run_once: true) do
+    that.configure # apply the default configuration at load time
+  end
 end

data/lib/generators/bidi2pdf_rails/USAGE

@@ -1,8 +1,16 @@
 Description:
-    Explain the generator
+    Generates a configuration file for Bidi2pdfRails in config/initializers/bidi2pdf_rails.rb
+    and adds development environment settings.
 
 Example:
-    bin/rails generate initializer Thing
+    bin/rails generate bidi2pdf_rails:initializer
 
-    This will create:
-        what/will/it/create
+    # With options
+    bin/rails generate bidi2pdf_rails:initializer --quiet    # Skip interactive prompts
+    bin/rails generate bidi2pdf_rails:initializer --force    # Overwrite existing config
+
+This will create:
+    config/initializers/bidi2pdf_rails.rb
+
+And add settings to:
+    config/environments/development.rb

data/lib/generators/bidi2pdf_rails/initializer_generator.rb

@@ -1,43 +1,72 @@
 module Bidi2pdfRails
   class InitializerGenerator < Rails::Generators::Base
     source_root File.expand_path("templates", __dir__)
-    desc "Generates a config/initializers/bidi2pdf.rb config file"
 
-    class_option :force, type: :boolean, default: false, desc: "Overwrite existing file"
-    class_option :quiet, type: :boolean, default: false, desc: "Skip prompts"
-
-    def ask_questions
-      return if options[:quiet]
+    def self.infer_option_type(default)
+      case default
+      when true, false then :boolean
+      when Numeric then :numeric
+      when Hash then :hash
+      when Array then :array
+      when Proc then :string
+      else :string
+      end
+    end
 
-      @log_network_events = yes?("Log network traffic? (y/n)", :green)
-      @log_browser_console = yes?("Log browser console output? (y/n)", :green)
-      @headless = yes?("Run Chrome in headless mode? (y/n)", :green)
-      @proxy = yes?("Use a proxy server? (y/n)", :green)
+    def self.normalize_group(key)
+      key.to_s.sub(/(_settings|_options)$/, "")
+    end
 
-      if @proxy
-        @proxy_addr = ask("Proxy address (e.g., 127.0.0.1):", :yellow)
-        @proxy_port = ask("Proxy port (e.g., 8080):", :yellow)
+    def self.with_group_config
+      that = self
+      Bidi2pdfRails::Config::CONFIG_OPTIONS.each_pair do |group_key, group_config|
+        group_prefix = that.normalize_group(group_key)
+        yield group_key, group_prefix, group_config
       end
+    end
 
-      @configure_viewport = yes?("Configure custom viewport? (y/n)", :green)
-      if @configure_viewport
-        @viewport_width = ask("Viewport width (e.g., 1920):", :yellow)
-        @viewport_height = ask("Viewport height (e.g., 1080):", :yellow)
+    def self.with_group_option
+      with_group_config do |group_key, group_prefix, group_config|
+        group_config[:options].each do |opt|
+          yield group_key, group_prefix, opt
+        end
       end
+    end
+
+    with_group_option do |_group_key, group_prefix, opt|
+      next unless opt[:ask]
+
+      name = "#{group_prefix}_#{opt[:name]}"
+      type = infer_option_type(opt[:default])
+      default = opt[:default_as_str] || opt[:default]
+
+      class_option name,
+                   type: type,
+                   desc: opt[:desc],
+                   default: default,
+                   enum: opt[:limited_to]
+    end
 
-      @configure_pdf = yes?("Configure custom PDF settings? (y/n)", :green)
-      if @configure_pdf
-        @pdf_orientation = ask("PDF orientation (portrait/landscape):", :yellow)
-        @pdf_margins = yes?("Configure PDF margins? (y/n)", :green)
-        if @pdf_margins
-          @pdf_margin_top = ask("PDF margin top (mm):", :yellow)
-          @pdf_margin_bottom = ask("PDF margin bottom (mm):", :yellow)
-          @pdf_margin_left = ask("PDF margin left (mm):", :yellow)
-          @pdf_margin_right = ask("PDF margin right (mm):", :yellow)
+    def ask_questions
+      @answers = {}
+
+      return if options[:quiet]
+
+      self.class.with_group_config do |_group_key, group_prefix, group_config|
+        next unless group_config[:ask]
+        if group_config[:ask]
+          next unless yes?(group_config[:ask], :green)
+        end
+
+        group_config[:options].select { |opt| opt[:ask] }.each do |opt|
+          option_key = "#{group_prefix}_#{opt[:name]}".to_sym
+          next if cli_option_set?(option_key, opt)
+
+          @answers[option_key] = prompt_for_option(opt)
         end
-        @pdf_print_background = yes?("Print background graphics? (y/n)", :green)
-        @pdf_scale = ask("PDF scale (e.g., 1.0):", :yellow)
       end
+
+      @answers.compact!
     end
 
     def generate_config
@@ -48,9 +77,10 @@ module Bidi2pdfRails
 
     def inject_environment_config
       env_file = "config/environments/development.rb"
+      env_path = File.join(destination_root, env_file)
 
-      if File.exist?(env_file)
-        if File.read(env_file).include?("config.x.bidi2pdf_rails")
+      if File.exist?(env_path)
+        if File.read(env_path).include?("config.x.bidi2pdf_rails")
           say_status :skipped, "Bidi2PDF settings already present in #{env_file}", :yellow
         else
           content = <<~RUBY.gsub(/^(?=[\w#])/, "  ")
@@ -69,5 +99,81 @@ module Bidi2pdfRails
         say_status :error, "Could not find #{env_file}", :red
       end
     end
+
+    no_commands do
+      def cli_option_set?(option_key, opt_def)
+        return false unless options.key?(option_key.to_s)
+
+        default = opt_def[:default_as_str] || opt_def[:default]
+        options[option_key.to_s].to_s != default.to_s
+      end
+
+      def prompt_for_option(opt)
+        type = self.class.infer_option_type(opt[:default])
+
+        if type == :boolean
+          question = opt[:desc].match?(/y\/n/i) ? opt[:desc] : "#{opt[:desc]} (y/n)?"
+          yes?(question, opt[:color])
+        else
+          opts = {
+            default: opt[:default_as_str] || opt[:default],
+            limited_to: opt[:limited_to],
+            echo: !opt[:secret]
+          }.compact
+
+          ask(opt[:desc], opt[:color], **opts)
+        end
+      end
+
+      def normalize_group(key)
+        self.class.normalize_group(key)
+      end
+    end
+
+    private
+
+    def changed_by_user?(full_top_level_name, option_name)
+      top_level_name = normalize_group full_top_level_name
+
+      full_qual_option_name = "#{top_level_name}_#{option_name}".to_sym
+      return false unless options.key?(full_qual_option_name.to_s)
+
+      option_def = Bidi2pdfRails::Config::CONFIG_OPTIONS.dig(full_top_level_name.to_sym, :options).find { |opt| opt[:name] == option_name.to_sym }
+      default = option_def[:default_as_str] ? option_def[:default_as_str] : option_def[:default]
+
+      current_value = get_option_value(top_level_name, option_name)
+
+      return false if default.nil? && current_value.empty?
+      return true if default.nil? && current_value.present?
+
+      !current_value.to_s.match /#{Regexp.escape(default.to_s)}/
+    end
+
+    def get_option_value(top_level_name, option_name)
+      top_level_name = top_level_name.to_s.sub(/(_settings)|(_options)$/, "")
+      full_qual_option_name = "#{top_level_name}_#{option_name}".to_sym
+
+      result = if @answers.key?(full_qual_option_name)
+                 @answers[full_qual_option_name]
+               elsif options.key?(full_qual_option_name.to_s)
+                 options[full_qual_option_name.to_s]
+               else
+                 nil
+               end
+
+      if result.is_a?(String)
+        if result.match(/(^\s+->\s+{)|(.*Rails\.)/) || numeric?(result)
+          return result
+        end
+        '"' + result + '"'
+      else
+        result
+      end
+    end
+
+    def numeric?(string)
+      # Float/Integer conversion with rescue catches most numeric formats
+      true if Float(string) rescue false
+    end
   end
 end