bidi2pdf-rails 0.0.1.pre.alpha → 0.1.0

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

data/lib/generators/bidi2pdf_rails/templates/bidi2pdf_rails.rb.tt

@@ -2,88 +2,34 @@
 
 Bidi2pdfRails.configure do |config|
   overrides = Rails.application.config.x.bidi2pdf_rails
-
-  config.notification_service = ActiveSupport::Notifications
-
-  config.logger = Rails.logger
-  config.verbosity = overrides.verbosity.nil? ? :none : overrides.verbosity
-  config.default_timeout = 10
-
-  # Logging options
-  config.log_network_events = <%= @log_network_events ? "true" : "false" %>
-  config.log_browser_console = <%= @log_browser_console ? "true" : "false" %>
-
-  # Chrome & BiDi
-  # config.remote_browser_url = nil
-  config.headless = overrides.headless.nil? ? <%= @headless ? "true" : "false" %> : overrides.headless
-  # config.chromedriver_port = 0
-  # config.chrome_session_args = [
-  #   "--disable-gpu",
-  #   "--no-sandbox"
-  # ]
-
-<% if @proxy %>
-  config.proxy_addr = "<%= @proxy_addr %>"
-  config.proxy_port = <%= @proxy_port %>
-  config.proxy_user = nil
-  config.proxy_pass = nil
-<% else %>
-  # config.proxy_addr = nil
-  # config.proxy_port = nil
-  # config.proxy_user = nil
-  # config.proxy_pass = nil
-<% end %>
-
-<% if @configure_viewport %>
-  # Viewport settings
-  config.viewport_width = <%= @viewport_width || 1920 %>
-  config.viewport_height = <%= @viewport_height || 1080 %>
-<% else %>
-  # Viewport settings
-  # config.viewport_width = 1920
-  # config.viewport_height = 1080
-<% end %>
-
-<% if @configure_pdf %>
-  # PDF settings
-  config.pdf_orientation = "<%= @pdf_orientation || "portrait" %>"
-  <% if @pdf_margins %>
-  config.pdf_margin_top = <%= @pdf_margin_top || 10 %>
-  config.pdf_margin_bottom = <%= @pdf_margin_bottom || 10 %>
-  config.pdf_margin_left = <%= @pdf_margin_left || 10 %>
-  config.pdf_margin_right = <%= @pdf_margin_right || 10 %>
-  <% else %>
-  # config.pdf_margin_top = 10
-  # config.pdf_margin_bottom = 10
-  # config.pdf_margin_left = 10
-  # config.pdf_margin_right = 10
-  <% end %>
-  config.pdf_print_background = <%= @pdf_print_background ? "true" : "false" %>
-  config.pdf_scale = <%= @pdf_scale || 1.0 %>
-<% else %>
-  # PDF settings
-  # config.pdf_orientation = "portrait"
-  # config.pdf_margin_top = 10
-  # config.pdf_margin_bottom = 10
-  # config.pdf_margin_left = 10
-  # config.pdf_margin_right = 10
-  # config.pdf_print_background = true
-  # config.pdf_scale = 1.0
+<%
+    Bidi2pdfRails::Config::CONFIG_OPTIONS.each_pair do |top_level_option_name, top_level_option|
+      name = top_level_option[:name]
+%>
+
+  #
+  # <%= name %>
+  #
+  <% top_level_option[:options].each do |option| %>
+  <% if option[:limited_to] %>
+  <%= "# Allowed values: #{option[:limited_to].map { |v| v.inspect }.join(", ")}" %>
+  <% end -%>
+<% if changed_by_user?(top_level_option_name, option[:name]) -%>
+<%= "config.#{top_level_option_name}.#{option[:name]} = #{get_option_value(top_level_option_name, option[:name]) } # #{option[:desc]}" -%>
+<% else -%>
+<%= "# config.#{top_level_option_name}.#{option[:name]} = #{option[:default_as_str] ? option[:default_as_str] : option[:default].inspect} # #{option[:desc]}" -%>
+<% end -%>
+  <% end -%>
 <% end %>
+end
 
-  # config.cookies = [
-  #   { name: "session", value: "abc123", domain: "example.com" }
-  # ]
+Rails.application.config.after_initialize do
+  Bidi2pdfRails::MainLogSubscriber.attach_to "bidi2pdf", inherit_all: true # needed for imported methods
+  Bidi2pdfRails::MainLogSubscriber.attach_to "bidi2pdf_rails", inherit_all: true # needed for imported methods
 
-  # config.headers = {
-  #   "X-API-KEY" => "topsecret"
-  # }
+  Bidi2pdfRails::BrowserConsoleLogSubscriber.attach_to "bidi2pdf"
 
-  # config.auth = {
-  #   username: "admin",
-  #   password: "secret"
-  # }
+  Bidi2pdfRails::MainLogSubscriber.silence /network_event_.*\.bidi2pdf/
 
-  # chromedriver install dir
-  # config.install_dir = Rails.root.join("tmp", "bidi2pdf").to_s
+  Bidi2pdfRails::NetworkLogSubscriber.attach_to "bidi2pdf"
 end

data/spec/acceptance/user_can_download_report_pdf_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+require "net/http"
+require "rack/handler/puma"
+require "socket"
+
+RSpec.feature "As a devoloper, I want to generate PDF's with bidi2pdf-rails", :pdf, type: :request do
+  # This feature demonstrates how to use bidi2pdf-rails to generate PDFs
+  # from Rails views, remote URLs, and inline HTML. These specs double as
+  # living documentation for gem users.
+
+  before(:all) do
+    # Prepare the PDF rendering engine (chromium, etc.)
+    Bidi2pdfRails::ChromedriverManagerSingleton.initialize_manager force: true
+  end
+
+  after(:all) do
+    Bidi2pdfRails::ChromedriverManagerSingleton.shutdown
+  end
+
+  scenario "Rendering a controller view to PDF using layout: 'pdf'" do
+    # Controller example:
+    #
+    # def show
+    #   respond_to do |format|
+    #     format.html
+    #     format.pdf { render pdf: 'my-report', layout: 'pdf' }
+    #   end
+    # end
+
+    when_ "I visit the PDF version of a report" do
+      before do
+        @response = get_pdf_response "/reports/1.pdf"
+      end
+
+      then_ "I receive a successful HTTP response" do
+        expect(@response.code).to eq("200")
+      end
+
+      and_ "I receive a PDF file in response" do
+        expect(@response['Content-Type']).to eq("application/pdf")
+      end
+
+      and_ "the PDF contains the expected number of pages" do
+        expect(@response.body).to have_pdf_page_count(5)
+      end
+
+      and_ "the disposition header is set to attachment" do
+        expect(@response['Content-Disposition']).to start_with('inline; filename="my-report.pdf"')
+      end
+
+      and_ "the PDF contains the expected content" do
+        expect(@response.body).to contains_pdf_text("Section Two").at_page(2)
+      end
+    end
+  end
+
+  scenario "Converting a remote URL into a PDF with custom options" do
+    # Controller usage:
+    #
+    # def convert_remote_url
+    #   render pdf: 'convert-remote-url', url: "http://example.com", wait_for_page_loaded: false, print_options: { page: { format: :A4 } }
+    # end
+
+    when_ "I visit the PDF version of a report" do
+      before do
+        @response = get_pdf_response "/convert-remote-url.pdf"
+      end
+
+      then_ "I receive a successful HTTP response" do
+        expect(@response.code).to eq("200")
+      end
+
+      and_ "I receive a PDF file in response" do
+        expect(@response['Content-Type']).to eq("application/pdf")
+      end
+
+      and_ "the PDF contains the expected number of pages" do
+        expect(@response.body).to have_pdf_page_count(1)
+      end
+
+      and_ "the disposition header is set to attachment" do
+        expect(@response['Content-Disposition']).to start_with('inline; filename="convert-remote-url.pdf"')
+      end
+    end
+  end
+
+  scenario "Rendering inline HTML directly to PDF" do
+    # Controller usage:
+    #
+    # def inline_html
+    #   html = <<~HTML
+    #   <html>
+    #   <head>
+    #   </head>
+    #   <body>
+    #    <h1>PDF Rendering Sample</h1>
+    #     <p style="page-break-after: always;">Page break</p>
+    #     <p>Content Page 2</p>
+    #   </body>
+    #  </html>
+    #
+    #   render pdf: 'inline-html', inline: html, wait_for_page_loaded: false, print_options: { page: { format: :A4 } }
+    # end
+
+    when_ "I visit the PDF version of a report" do
+      before do
+        @response = get_pdf_response "/inline-html.pdf"
+      end
+
+      then_ "I receive a successful HTTP response" do
+        expect(@response.code).to eq("200")
+      end
+
+      and_ "I receive a PDF file in response" do
+        expect(@response['Content-Type']).to eq("application/pdf")
+      end
+
+      and_ "the PDF contains the expected number of pages" do
+        expect(@response.body).to have_pdf_page_count(2)
+      end
+
+      and_ "the disposition header is set to attachment" do
+        expect(@response['Content-Disposition']).to start_with('inline; filename="inline-html.pdf"')
+      end
+
+      and_ "the PDF contains the expected content" do
+        expect(@response.body).to contains_pdf_text("PDF Rendering Sample")
+      end
+    end
+  end
+end