weasy_pdf 0.1.0

data/lib/weasy_pdf/renderer.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+require "securerandom"
+require "timeout"
+require "net/http"
+
+module WeasyPDF
+  class Renderer
+    # WeasyPrint-relevant options that the renderer reads.
+    # Any other keys in the options hash are silently ignored —
+    # this allows wkhtmltopdf options to be passed without error during migration.
+    WEASYPRINT_OPTIONS = %i[
+      page_size page_height page_width orientation
+      margin margin_top margin_bottom margin_left margin_right
+      encoding zoom media_type base_url stylesheets
+      header footer save_to_file save_only
+    ].freeze
+
+    def initialize(options = {})
+      merged = WeasyPDF.configuration.default_options.merge(options)
+      # :wkhtmltopdf was WickedPdf's per-instance binary override — accept it as exe_path
+      # so apps that pass it during migration don't need to change that option key.
+      @binary = merged.delete(:wkhtmltopdf) || WeasyPDF.configuration.exe_path
+      @timeout = merged.delete(:timeout) || WeasyPDF.configuration.timeout
+      @options = merged.slice(*WEASYPRINT_OPTIONS)
+      validate_binary!
+    end
+
+    def pdf_from_string(html_string, options = {})
+      opts = @options.merge(options)
+      html = inject_page_css(html_string, opts)
+
+      FileUtils.mkdir_p(WeasyPDF.configuration.temp_path)
+      input = write_temp_html(html)
+      output = temp_pdf_path
+
+      begin
+        run!(input, output, opts)
+        result = File.binread(output)
+
+        if opts[:save_to_file]
+          FileUtils.mkdir_p(File.dirname(opts[:save_to_file].to_s))
+          File.binwrite(opts[:save_to_file].to_s, result)
+          return nil if opts[:save_only]
+        end
+
+        result
+      ensure
+        FileUtils.rm_f([input, output])
+      end
+    end
+
+    def pdf_from_html_file(filepath, options = {})
+      raise ArgumentError, "File not found: #{filepath}" unless File.exist?(filepath)
+
+      pdf_from_string(File.read(filepath.to_s, encoding: "utf-8"), options)
+    end
+
+    def pdf_from_url(url, options = {})
+      response = Net::HTTP.get_response(URI.parse(url))
+      raise WeasyPDF::Error, "HTTP #{response.code} fetching #{url}" \
+        unless response.is_a?(Net::HTTPSuccess)
+
+      pdf_from_string(response.body, options)
+    end
+
+    private
+
+    # ── Execution ─────────────────────────────────────────────────────────
+
+    def run!(input_path, output_path, options = {})
+      cmd = build_command(input_path, output_path, options)
+      Timeout.timeout(@timeout) do
+        _out, err, status = Open3.capture3(*cmd)
+        unless status.success?
+          raise GenerationError,
+            "WeasyPrint failed (exit #{status.exitstatus}): #{err.strip}"
+        end
+      end
+    rescue ::Timeout::Error
+      raise WeasyPDF::TimeoutError, "WeasyPrint timed out after #{@timeout}s"
+    end
+
+    def build_command(input_path, output_path, options = {})
+      # Resolve base_url here so CommandBuilder stays free of global state.
+      resolved = options[:base_url] || WeasyPDF.configuration.base_url
+      opts = resolved ? options.merge(base_url: resolved) : options
+      CommandBuilder.new(@binary, opts).build(input_path, output_path)
+    end
+
+    # ── CSS @page injection ───────────────────────────────────────────────
+
+    def inject_page_css(html, options = {})
+      css = build_page_css(options)
+      tag = "<style>\n#{css}\n</style>"
+      if html.match?(/<head[^>]*>/i)
+        html.sub(/<head[^>]*>/i) { |m| "#{m}\n#{tag}" }
+      else
+        "#{tag}\n#{html}"
+      end
+    end
+
+    def build_page_css(options = {})
+      lines = ["@page { size: #{page_size_str(options)}; margin: #{build_margin_string(options)}; }"]
+
+      # Header/footer via CSS @page margin boxes.
+      # :html/:template options are rejected by PdfHelper before reaching here.
+      add_header_footer_css(lines, options[:header], "@top")
+      add_header_footer_css(lines, options[:footer], "@bottom")
+
+      lines.join("\n")
+    end
+
+    def page_size_str(options)
+      case options
+      in {page_height: (Integer | String) => h, page_width: (Integer | String) => w}
+        "#{w}mm #{h}mm"
+      in {orientation: /\Alandscape\z/i}
+        "#{options[:page_size] || "A4"} landscape"
+      else
+        options[:page_size] || "A4"
+      end
+    end
+
+    def build_margin_string(options = {})
+      m = options[:margin] || {}
+      top = m[:top] || options[:margin_top] || "10mm"
+      bottom = m[:bottom] || options[:margin_bottom] || "10mm"
+      left = m[:left] || options[:margin_left] || "10mm"
+      right = m[:right] || options[:margin_right] || "10mm"
+
+      top, right_m, bottom, left = [top, right, bottom, left].map { |v| v.is_a?(Numeric) ? "#{v}mm" : v.to_s }
+      "#{top} #{right_m} #{bottom} #{left}"
+    end
+
+    def add_header_footer_css(lines, hf, position)
+      return unless hf.is_a?(Hash)
+
+      # Only simple text content here — :html/:template are rejected before reaching Renderer.
+      {
+        left: "#{position}-left",
+        center: "#{position}-center",
+        right: "#{position}-right"
+      }.each do |key, box|
+        next unless hf[key].is_a?(String)
+
+        content_val = wkhtml_to_css_content(hf[key])
+        font_style = css_font_style(hf)
+        lines << "@page { #{box} { content: #{content_val}; #{font_style} } }"
+      end
+    end
+
+    def wkhtml_to_css_content(str)
+      # Unsupported tokens ([section], [title], etc.) are silently removed.
+      # NUL byte (\x00) is the split sentinel: it can't appear in CSS text,
+      # so it cleanly separates literal strings from counter names after split.
+      parts = str.gsub("[page]", "\x00page\x00")
+        .gsub("[topage]", "\x00pages\x00")
+        .gsub(/\[[^\]]+\]/, "")
+        .split("\x00")
+
+      segments = parts.map.with_index do |part, i|
+        if i.odd?
+          "counter(#{part})"
+        else
+          part.empty? ? nil : "\"#{esc(part)}\""
+        end
+      end.compact
+
+      segments.empty? ? '""' : segments.join(" ")
+    end
+
+    def css_font_style(hf)
+      parts = []
+      parts << "font-family: #{hf[:font_name]};" if hf[:font_name]
+      parts << "font-size: #{hf[:font_size]}pt;" if hf[:font_size]
+      parts.join(" ")
+    end
+
+    # Block form: gsub's string-replacement syntax interprets \\ as an escape,
+    # so gsub("\\", "\\\\") is silently a no-op. Block form takes the replacement verbatim.
+    def esc(str)
+      str.to_s.gsub("\\") { "\\\\" }.gsub('"') { '\\"' }
+    end
+
+    # ── Temp files ────────────────────────────────────────────────────────
+
+    def write_temp_html(html)
+      path = WeasyPDF.configuration.temp_path.join("weasy_#{SecureRandom.hex(8)}.html").to_s
+      File.write(path, html, encoding: "utf-8")
+      path
+    end
+
+    def temp_pdf_path
+      WeasyPDF.configuration.temp_path.join("weasy_#{SecureRandom.hex(8)}.pdf").to_s
+    end
+
+    # ── Validation ────────────────────────────────────────────────────────
+
+    def validate_binary!
+      bin = @binary.to_s
+      return if File.executable?(bin)
+      # bare name (no '/') — File.executable? only checks CWD, so search PATH explicitly
+      return if !bin.include?("/") &&
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? { |d| File.executable?(File.join(d, bin)) }
+
+      raise BinaryNotFoundError,
+        "WeasyPrint binary not found at '#{@binary}'.\n  " \
+        "Install with: apt install weasyprint   (Debian/Ubuntu)\n                " \
+        "brew install weasyprint  (macOS)\n                " \
+        "pip install weasyprint   (latest version)\n  " \
+        "Or configure: WeasyPDF.configure { |c| c.exe_path = '/path/to/weasyprint' }"
+    end
+  end
+end

data/lib/weasy_pdf/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WeasyPDF
+  VERSION = "0.1.0"
+end

data/lib/weasy_pdf/view_helpers/assets.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module WeasyPDF
+  module ViewHelpers
+    # Base asset helpers. Resolves assets from public/ directories on disk.
+    # When vite_ruby is present, ViteAssets is included on top and overrides
+    # resolution to use the Vite manifest instead.
+    module Assets
+      ASSET_URL_REGEX = /url\(['"]?([^'")\s]+?)['"]?\)/
+
+      # ── Stylesheets ────────────────────────────────────────────────────
+
+      def weasy_pdf_stylesheet_link_tag(*sources)
+        sources.map do |source|
+          source = add_extension(source, "css")
+          path = find_asset_path(source) { raise WeasyPDF::MissingLocalAsset, source }
+          css = File.read(path, encoding: "utf-8")
+          css = rewrite_asset_urls(css)
+          "<style type='text/css'>#{css}</style>"
+        end.join("\n").html_safe
+      end
+
+      # ── Images ─────────────────────────────────────────────────────────
+
+      def weasy_pdf_image_tag(source, options = {})
+        image_tag(weasy_pdf_asset_path(source), options)
+      end
+
+      # ── Asset paths ────────────────────────────────────────────────────
+
+      def weasy_pdf_asset_path(asset)
+        return asset if asset.to_s.start_with?("http://", "https://", "data:", "//")
+
+        resolve_asset_path(asset)
+      end
+
+      def weasy_pdf_asset_base64(path)
+        disk = find_asset_path(path) { raise WeasyPDF::MissingLocalAsset, path }
+        base64 = Base64.strict_encode64(File.binread(disk))
+        "data:#{mime_for(path)};base64,#{base64}"
+      end
+
+      def weasy_pdf_url_base64(url)
+        require "net/http"
+        response = Net::HTTP.get_response(URI.parse(url))
+        raise WeasyPDF::MissingRemoteAsset.new(url, response) unless response.is_a?(Net::HTTPSuccess)
+
+        base64 = Base64.strict_encode64(response.body.b)
+        "data:#{response.content_type};base64,#{base64}"
+      end
+
+      private
+
+      # ── Resolution ────────────────────────────────────────────────────
+
+      def find_asset_path(source)
+        strip = source.sub(%r{\A/(?:vite/assets/|assets/)}, "")
+        raw = source.sub(%r{\A/}, "")
+
+        [
+          Rails.root.join("public", "vite", "assets", strip),
+          Rails.root.join("public", "assets", raw),
+          Rails.root.join("public", raw)
+        ].each do |path|
+          return path.to_s if File.exist?(path.to_s)
+        end
+
+        block_given? ? yield : nil
+      end
+
+      def resolve_asset_path(asset)
+        path = find_asset_path(asset)
+        return "file://#{path}" if path
+
+        if WeasyPDF.configuration.base_url
+          sep = asset.start_with?("/") ? "" : "/"
+          return "#{WeasyPDF.configuration.base_url}#{sep}#{asset}"
+        end
+
+        Rails.logger.warn("[WeasyPDF] Could not resolve '#{asset}' to an absolute path.") if defined?(Rails)
+        asset
+      end
+
+      # CSS inlined from a temp file in /tmp has no base path, so relative url()
+      # references would resolve against /tmp rather than the Rails public/ tree.
+      def rewrite_asset_urls(css)
+        css.gsub(ASSET_URL_REGEX) do
+          url = Regexp.last_match[1]
+          url.start_with?("data:") ? "url(#{url})" : "url(#{weasy_pdf_asset_path(url)})"
+        end
+      end
+
+      def mime_for(source)
+        case File.extname(source.to_s).downcase
+        when ".png" then "image/png"
+        when ".jpg", ".jpeg" then "image/jpeg"
+        when ".gif" then "image/gif"
+        when ".svg" then "image/svg+xml"
+        when ".webp" then "image/webp"
+        when ".avif" then "image/avif"
+        when ".css" then "text/css"
+        else "application/octet-stream"
+        end
+      end
+
+      def add_extension(source, ext)
+        source.end_with?(".#{ext}") ? source : "#{source}.#{ext}"
+      end
+    end
+  end
+end

data/lib/weasy_pdf/view_helpers/vite_assets.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module WeasyPDF
+  module ViewHelpers
+    # Included on top of Assets when vite_ruby is available.
+    # Overrides asset resolution to use ViteRuby's manifest.
+    module ViteAssets
+      def weasy_pdf_stylesheet_link_tag(*sources)
+        sources.map { |source| resolve_vite_stylesheet(source) }.join("\n").html_safe
+      end
+
+      # weasy_pdf_image_tag is inherited from Assets — it calls weasy_pdf_asset_path,
+      # which IS overridden here, so override-by-dispatch is enough. No re-definition needed.
+
+      def weasy_pdf_asset_path(asset)
+        return asset if asset.to_s.start_with?("http://", "https://", "data:", "//")
+
+        url = vite_asset_url(asset)
+
+        if cdn_url?(url)
+          url
+        elsif vite_dev_server_running?
+          content = fetch_bytes(url)
+          "data:#{mime_for(asset)};base64,#{Base64.strict_encode64(content)}"
+        else
+          disk = disk_path_from_url(url)
+          (disk && File.exist?(disk.to_s)) ? "file://#{disk}" : url
+        end
+      end
+
+      private
+
+      # Strategy progression: CDN URL → dev server (HTTP) → compiled file on disk → fallback link.
+      # Each branch returns the same shape (a tag string), so the caller can treat them uniformly.
+      def resolve_vite_stylesheet(source)
+        url = vite_asset_url(source)
+        return stylesheet_link(url) if cdn_url?(url)
+        return inlined_stylesheet(source, fetch_text(url)) if vite_dev_server_running?
+
+        disk = disk_path_from_url(url)
+        if disk && File.exist?(disk.to_s)
+          inlined_stylesheet(source, File.read(disk.to_s, encoding: "utf-8"))
+        else
+          warn_missing_vite_asset(source, url) if WeasyPDF.configuration.base_url.nil?
+          stylesheet_link(url)
+        end
+      end
+
+      def stylesheet_link(url)
+        "<link rel='stylesheet' type='text/css' href='#{url}' />"
+      end
+
+      def inlined_stylesheet(source, css)
+        "<style type='text/css'>/* #{source} */\n#{css}</style>"
+      end
+
+      def warn_missing_vite_asset(source, url)
+        Rails.logger.warn(
+          "[WeasyPDF] Asset '#{source}' -> '#{url}' not found on disk. " \
+          "Run bin/vite build or set WeasyPDF.configure { |c| c.base_url = ... }"
+        )
+      end
+
+      def vite_asset_url(source)
+        ViteRuby.instance.manifest.path_for(source)
+      rescue
+        respond_to?(:asset_path, true) ? asset_path(source) : "/#{source}"
+      end
+
+      def vite_dev_server_running?
+        ViteRuby.instance.dev_server_running?
+      end
+
+      def cdn_url?(url)
+        # Localhost URLs look like external URLs but are actually the Vite dev server.
+        url.to_s.match?(%r{\Ahttps?://}) &&
+          !url.to_s.match?(/localhost|127\.0\.0\.1/)
+      end
+
+      def disk_path_from_url(url)
+        return nil unless url.to_s.start_with?("/")
+
+        Rails.root.join("public", url.sub(%r{\A/}, ""))
+      end
+
+      def fetch_text(url)
+        fetch_bytes(url).encode("utf-8", "binary", invalid: :replace, undef: :replace)
+      end
+
+      def fetch_bytes(url)
+        require "net/http"
+        uri = URI.parse(url)
+        response = Net::HTTP.get_response(uri)
+        raise WeasyPDF::MissingRemoteAsset.new(url, response) \
+          unless response.is_a?(Net::HTTPSuccess)
+
+        response.body.b
+      rescue WeasyPDF::MissingRemoteAsset
+        raise
+      rescue => e
+        # Network errors during asset resolution shouldn't abort PDF generation;
+        # the caller logs and degrades to a <link> tag or omits the asset.
+        Rails.logger.warn("[WeasyPDF] Error fetching #{url}: #{e.message}")
+        "".b
+      end
+    end
+  end
+end

data/lib/weasy_pdf.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "weasy_pdf/version"
+require "weasy_pdf/configuration"
+require "weasy_pdf/command_builder"
+require "weasy_pdf/renderer"
+require "weasy_pdf/pdf_helper"
+require "weasy_pdf/middleware"
+require "weasy_pdf/view_helpers/assets"
+require "weasy_pdf/view_helpers/vite_assets"
+
+module WeasyPDF
+  class Error < StandardError; end
+  class BinaryNotFoundError < Error; end
+  class GenerationError < Error; end
+  class TimeoutError < Error; end
+  class MissingAsset < Error; end
+
+  class MissingLocalAsset < MissingAsset
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+      super("Asset not found: '#{path}'")
+    end
+  end
+
+  class MissingRemoteAsset < MissingAsset
+    attr_reader :url, :response
+
+    def initialize(url, response)
+      @url = url
+      @response = response
+      super("Could not fetch '#{url}': #{response.code} #{response.message}")
+    end
+  end
+
+  class << self
+    def configure
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def config
+      configuration
+    end
+
+    def config=(hash)
+      hash.each { |k, v| configuration[k] = v }
+    end
+
+    # Some WickedPdf initializers call clear_config between requests — alias reset! for drop-in compat.
+    def clear_config
+      reset!
+    end
+
+    def reset!
+      @configuration = Configuration.new
+    end
+
+    # No-op for API compat — WeasyPDF has no deprecation warnings to silence.
+    def silence_deprecations
+    end
+
+    # Drop-in equivalent of WickedPdf.new — returns a Renderer instance.
+    # WeasyPDF.new(options).pdf_from_string(html) ≡ WickedPdf.new.pdf_from_string(html).
+    def new(options = {})
+      Renderer.new(options)
+    end
+  end
+end
+
+require "weasy_pdf/railtie" if defined?(Rails::Railtie)

data/sig/configuration.rbs

@@ -0,0 +1,16 @@
+module WeasyPDF
+  class Configuration
+    DEFAULTS: Hash[Symbol, untyped]
+    BINARY_CANDIDATES: Array[String]
+
+    attr_accessor exe_path: String
+    attr_accessor default_options: Hash[Symbol, untyped]
+    attr_accessor base_url: String?
+    attr_accessor timeout: Integer
+    attr_accessor temp_path: Pathname
+
+    def initialize: () -> void
+    def []: (Symbol key) -> untyped
+    def []=: (Symbol key, untyped value) -> untyped
+  end
+end

data/sig/renderer.rbs

@@ -0,0 +1,10 @@
+module WeasyPDF
+  class Renderer
+    WEASYPRINT_OPTIONS: Array[Symbol]
+
+    def initialize: (?Hash[Symbol, untyped] options) -> void
+    def pdf_from_string: (String html_string, ?Hash[Symbol, untyped] options) -> String?
+    def pdf_from_html_file: (String | Pathname filepath, ?Hash[Symbol, untyped] options) -> String?
+    def pdf_from_url: (String url, ?Hash[Symbol, untyped] options) -> String?
+  end
+end

data/sig/weasy_pdf.rbs

@@ -0,0 +1,40 @@
+module WeasyPDF
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  class BinaryNotFoundError < Error
+  end
+
+  class GenerationError < Error
+  end
+
+  class TimeoutError < Error
+  end
+
+  class MissingAsset < Error
+  end
+
+  class MissingLocalAsset < MissingAsset
+    attr_reader path: String
+
+    def initialize: (String path) -> void
+  end
+
+  class MissingRemoteAsset < MissingAsset
+    attr_reader url: String
+    attr_reader response: untyped
+
+    def initialize: (String url, untyped response) -> void
+  end
+
+  def self.configure: () { (Configuration) -> void } -> void
+  def self.configuration: () -> Configuration
+  def self.config: () -> Configuration
+  def self.config=: (Hash[Symbol, untyped] hash) -> void
+  def self.clear_config: () -> Configuration
+  def self.reset!: () -> Configuration
+  def self.silence_deprecations: () -> void
+  def self.new: (?Hash[Symbol, untyped] options) -> Renderer
+end