bidi2pdf-rails 0.0.1.alpha.1 → 0.1.0

data/lib/generators/bidi2pdf_rails/initializer_generator.rb

@@ -1,44 +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_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 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
-        @pdf_page = yes?("Configure PDF page size? (y/n)", :green)
-        if @pdf_page
-          @pdf_page_width = ask("PDF page width (mm):", :yellow)
-          @pdf_page_height = ask("PDF page height (mm):", :yellow)
+      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
+
+    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
 
-        @pdf_print_background = yes?("Print background graphics? (y/n)", :green)
-        @pdf_scale = ask("PDF scale (e.g., 1.0):", :yellow)
-        @shrink_to_fit = ask("Shrink to fit? (y/n)", :green)
+        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
       end
+
+      @answers.compact!
     end
 
     def generate_config
@@ -49,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#])/, "  ")
@@ -70,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,111 +2,25 @@
 
 Bidi2pdfRails.configure do |config|
   overrides = Rails.application.config.x.bidi2pdf_rails
+<%
+    Bidi2pdfRails::Config::CONFIG_OPTIONS.each_pair do |top_level_option_name, top_level_option|
+      name = top_level_option[:name]
+%>
 
-  config.notification_service = ActiveSupport::Notifications
-
-  config.logger = Rails.logger
-  config.verbosity = overrides.verbosity.nil? ? :none : overrides.verbosity
-  config.default_timeout = 10
-
-  # Chrome & BiDi
-  # config.remote_browser_url = nil
-  config.headless = overrides.headless.nil? ? <%= @headless ? "true" : "false" %> : overrides.headless
-  #
-  # alternative to remote_browser_url
-  #
-  # 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 %>
-
-  # PDF settings (css media settings take precedence over these)
-<% if @configure_pdf %>
-
-  config.pdf_orientation = "<%= @pdf_orientation || "portrait" %>"
-  <% if @pdf_margins %>
-  config.pdf_margin_top = <%= @pdf_margin_top || 2.5 %>
-  config.pdf_margin_bottom = <%= @pdf_margin_bottom || 2 %>
-  config.pdf_margin_left = <%= @pdf_margin_left || 2 %>
-  config.pdf_margin_right = <%= @pdf_margin_right || 2 %>
-  <% else %>
-  # config.pdf_margin_top = 2.5
-  # config.pdf_margin_bottom = 2
-  # config.pdf_margin_left = 2
-  # config.pdf_margin_right = 2
-  <% end %>
-
-  <% if @pdf_page %>
-    # Page settings
-    config.pdf_page_width = <%= @pdf_page_width || Bidi2pdf::PAPER_FORMATS_CM[:a4][:width] %>
-    config.pdf_page_height = <%= @pdf_page_height || Bidi2pdf::PAPER_FORMATS_CM[:a4][:height] %>
-  <% else %>
-    # Page settings
-    # config.pdf_page_format = "A4"
-    #
-    # or custom page size
-    #
-    # config.pdf_page_width = <%= Bidi2pdf::PAPER_FORMATS_CM[:a4][:width] %>
-    # config.pdf_page_height = <%= Bidi2pdf::PAPER_FORMATS_CM[:a4][:height] %>
-  <% end %>
-
-  config.pdf_print_background = <%= @pdf_print_background ? "true" : "false" %>
-  config.pdf_scale = <%= @pdf_scale || 1.0 %>
-  config.shrink_to_fit = <%= @shrink_to_fit ? "true" : "false" %>
-<% else %>
-  # config.pdf_orientation = "portrait"
-  # config.pdf_margin_top = 2.5
-  # config.pdf_margin_bottom = 2
-  # config.pdf_margin_left = 2
-  # config.pdf_margin_right = 2
-  # config.pdf_print_background = true
-  # config.pdf_scale = 1.0
-  # config.shrink_to_fit = true
-
-  # Page settings
-  # config.pdf_page_format = "A4"
   #
-  # or custom page size
+  # <%= name %>
   #
-  # config.pdf_page_width = <%= Bidi2pdf::PAPER_FORMATS_CM[:a4][:width] %>
-  # config.pdf_page_height = <%= Bidi2pdf::PAPER_FORMATS_CM[:a4][:height] %>
+  <% 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 %>
-
-  # config.cookies = [
-  #   { name: "session", value: "abc123", domain: "example.com" }
-  # ]
-
-  # config.headers = {
-  #   "X-API-KEY" => "topsecret"
-  # }
-
-  # config.auth = {
-  #   username: "admin",
-  #   password: "secret"
-  # }
-
-  # chromedriver install dir
-  # config.install_dir = Rails.root.join("tmp", "bidi2pdf").to_s
-
-  # wait for the page to load settings
-  # config.wait_for_network_idle = true
-  # config.wait_for_page_loaded = false
-  # this script can be any valid JS script that returns a Promise
-  # it will wait for the Promise to resolve
-  # config.wait_for_page_check_script = nil
 end
 
 Rails.application.config.after_initialize do

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

data/spec/acceptance/user_can_generate_pdf_from_protected_remote_url_spec.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+require "net/http"
+require "rack/handler/puma"
+require "socket"
+require "base64"
+
+RSpec.feature "As a user, I want to generate a PDF from a protected remote URL", :pdf, type: :request do
+  before(:all) do
+    # Bidi2pdfRails.config.general_options.headless = false
+    Bidi2pdfRails::ChromedriverManagerSingleton.initialize_manager force: true
+  end
+
+  after(:all) do
+    Bidi2pdfRails::ChromedriverManagerSingleton.shutdown
+  end
+
+  scenario "Using basic auth for remote PDF rendering" do
+    # Controller setup:
+    #
+    # You can configure basic auth in two ways:
+    #
+    # 1. In an initializer (global config):
+    #
+    #   Bidi2pdfRails.configure do |config|
+    #     config.render_remote_settings.basic_auth_user = ->(_controller) { "admin" }
+    #     config.render_remote_settings.basic_auth_pass = ->(_controller) { "secret" }
+    #   end
+    #
+    # 2. Inline within controller action:
+    #
+    #   render pdf: 'convert-remote-url-basic-auth',
+    #          url: basic_auth_endpoint_url(only_path: false),
+    #          auth: { username: "admin", password: "secret" }
+
+    when_ "I request a PDF generated from a basic-auth protected page" do
+      before do
+        with_render_setting :basic_auth_user, ->(_controller) { "admin" }
+        # in prod better to use:
+        # Bidi2pdfRails.config.render_remote_settings.basic_auth_pass = ->(_controller) { Rails.application.credentials.dig('bidi2pdf_rails', 'basic_auth_pass') }
+        with_render_setting :basic_auth_pass, ->(_controller) { "secret" }
+
+        @response = get_pdf_response "/convert-remote-url-basic-auth"
+      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-basic-auth.pdf"')
+      end
+
+      and_ "the PDF contains the expected content" do
+        expect(@response.body).to contains_pdf_text("This page is secured with: HTTPBasicAuthentication").at_page(1)
+      end
+    end
+  end
+
+  scenario "Using a session cookie for remote PDF rendering" do
+    # Controller setup:
+    #
+    # You can configure cookies in two ways:
+    #
+    # 1. In an initializer (global config):
+    #
+    #   Bidi2pdfRails.configure do |config|
+    #     config.render_remote_settings.cookies = = ->(controller) { { "auth_token" => signed_cookie_value("valid-authentication-token", controller) } }
+    #   end
+    #
+    # 2. Inline within controller action:
+    #
+    #     render pdf: 'convert-remote-url-cookie',
+    #            url: cookie_endpoint_url(only_path: false),
+    #            wait_for_page_loaded: false,
+    #            cookies: { "auth_token" => signed_cookie_value("valid-authentication-token", controller) }
+    #
+
+    when_ "I request a PDF from a page that requires a session cookie" do
+      def signed_cookie_value(value, controller)
+        request = controller.request
+        secret = request.key_generator.generate_key(request.signed_cookie_salt)
+        # Sign the value
+        verifier = ActiveSupport::MessageVerifier.new(secret)
+        verifier.generate(value)
+      end
+
+      before do
+        with_render_setting :cookies, ->(controller) { { "auth_token" => signed_cookie_value("valid-authentication-token", controller) } }
+
+        @response = get_pdf_response "/convert-remote-url-cookie"
+      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-cookie.pdf"')
+      end
+
+      and_ "the PDF contains the expected content" do
+        expect(@response.body).to contains_pdf_text("Protected Resource This page is secured with: CookieAuthentication").at_page(1)
+      end
+    end
+  end
+
+  scenario "Using custom headers for remote PDF rendering" do
+    # Controller setup:
+    #
+    # You can configure headers in two ways:
+    #
+    # 1. In an initializer (global config):
+    #
+    #   Bidi2pdfRails.configure do |config|
+    #    config.render_remote_settings.headers = ->(controller) { { "X-API-Key" => "your-secret-api-key" } }
+    #   end
+    #
+    # 2. Inline within controller action:
+    #
+    #     render pdf: 'convert-remote-url-cookie',
+    #            url: api_endpoint_url(only_path: false),
+    #            wait_for_page_loaded: false,
+    #            headers: { "X-API-Key" => "your-secret-api-key" }
+    #
+
+    when_ "I request a PDF from a page that requires an auth header" do
+      before do
+        @old_headers = Bidi2pdfRails.config.render_remote_settings.headers
+        with_render_setting :headers, ->(_controller) { { "X-API-Key" => "your-secret-api-key" } }
+
+        @response = get_pdf_response "/convert-remote-url-header"
+      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-cookie.pdf"')
+      end
+
+      and_ "the PDF contains the expected content" do
+        expect(@response.body).to contains_pdf_text("Protected Resource This page is secured with: API KeyAuthentication").at_page(1)
+      end
+    end
+  end
+end

data/spec/dummy/app/controllers/reports_controller.rb

@@ -6,7 +6,40 @@ class ReportsController < ApplicationController
     end
   end
 
-  def print_remote
-    render pdf: 'remote-report', url: "http://example.com", wait_for_page_loaded: false, print_options: { page: { format: :A4 } }
+  def convert_remote_url
+    render pdf: 'convert-remote-url', url: "http://example.com", wait_for_page_loaded: false, print_options: { page: { format: :A4 } }
+  end
+
+  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>
+    HTML
+    render pdf: 'inline-html', inline: html, wait_for_page_loaded: false, print_options: { page: { format: :A4 } }
+  end
+
+  def convert_remote_url_basic_auth
+    render pdf: 'convert-remote-url-basic-auth',
+           url: basic_auth_endpoint_url(only_path: false),
+           wait_for_page_loaded: false
+  end
+
+  def convert_remote_url_cookie
+    render pdf: 'convert-remote-url-cookie',
+           url: cookie_endpoint_url(only_path: false),
+           wait_for_page_loaded: false
+  end
+
+  def convert_remote_url_header
+    render pdf: 'convert-remote-url-cookie',
+           url: api_endpoint_url(only_path: false),
+           wait_for_page_loaded: false
   end
 end