docpdf 0.1.0

data/lib/docpdf/adapters/converters/soffice.rb

@@ -0,0 +1,61 @@
+require "tempfile"
+require_relative "base"
+
+module DocPDF
+  module Adapters
+    module Converters
+      class Soffice < Base
+        MIME_TYPES = %w[
+          application/msword
+          application/vnd.openxmlformats-officedocument.wordprocessingml.document
+          application/vnd.ms-excel
+          application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+          application/vnd.ms-powerpoint
+          application/vnd.openxmlformats-officedocument.presentationml.presentation
+          application/vnd.oasis.opendocument.text
+          application/vnd.oasis.opendocument.spreadsheet
+          application/vnd.oasis.opendocument.presentation
+          text/csv
+          text/html
+          text/rtf
+          application/rtf
+        ].freeze
+
+        class << self
+          def convert(data, source_filename)
+            Dir.mktmpdir do |output_dir|
+              Tempfile.create(["docpdf", File.extname(source_filename || ".tmp")]) do |tempfile|
+                tempfile.binmode
+                tempfile.write(data)
+                tempfile.rewind
+
+                soffice = DocPDF.configuration.soffice_path
+                stderr_path = File.join(output_dir, "stderr.log")
+                success = system(soffice, "--headless", "--convert-to", "pdf",
+                                 "--outdir", output_dir, tempfile.path,
+                                 out: File::NULL, err: stderr_path)
+
+                pdf_path = Dir.glob(File.join(output_dir, "*.pdf")).first
+
+                if pdf_path
+                  File.binread(pdf_path)
+                else
+                  stderr_output = File.read(stderr_path).strip
+                  detail = stderr_output.empty? ? "" : " (#{stderr_output})"
+
+                  if success.nil?
+                    raise SofficeNotFoundError, "LibreOffice (soffice) not found on PATH. Install LibreOffice or set DocPDF.configuration.soffice_path."
+                  elsif success
+                    raise ConversionError, "LibreOffice completed but produced no PDF for #{source_filename || 'document'}#{detail}"
+                  else
+                    raise ConversionError, "LibreOffice failed to convert #{source_filename || 'document'} to PDF#{detail}"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docpdf/adapters/stampers/base.rb

@@ -0,0 +1,22 @@
+module DocPDF
+  module Adapters
+    module Stampers
+      class Base
+        class << self
+          def stamp(data, stamps, page_indices: nil)
+            raise NotImplementedError, "#{name} must implement .stamp(data, stamps, page_indices:)"
+          end
+
+          private
+
+          def rotated_bounds(w, h, degrees)
+            radians = degrees * Math::PI / 180.0
+            cos = Math.cos(radians).abs
+            sin = Math.sin(radians).abs
+            [(w * cos + h * sin).ceil, (w * sin + h * cos).ceil]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docpdf/adapters/stampers/combine_pdf.rb

@@ -0,0 +1,116 @@
+require "combine_pdf"
+require "prawn"
+require_relative "base"
+
+module DocPDF
+  module Adapters
+    module Stampers
+      class CombinePdf < Base
+        class << self
+          def stamp(data, stamps, page_indices: nil)
+            source = ::CombinePDF.parse(data)
+            source_page = source.pages.first
+            page_w = source_page[:MediaBox][2].to_f
+            page_h = source_page[:MediaBox][3].to_f
+
+            stamp_page_data = generate_stamp_page(stamps, page_w, page_h)
+            stamp_page = ::CombinePDF.parse(stamp_page_data).pages.first
+
+            source.pages.each_with_index do |page, idx|
+              page << stamp_page if page_indices.nil? || page_indices.include?(idx)
+            end
+            source.to_pdf
+          rescue ::CombinePDF::ParsingError => e
+            raise ConversionError, "CombinePDF failed to stamp PDF: #{e.message}"
+          end
+
+          private
+
+          def fit_font_size(font_size, text, pdf, page_w, page_h)
+            max_dim = [page_w, page_h].max * 0.9
+            text_w = pdf.width_of(text, size: font_size)
+            return font_size if text_w <= max_dim
+
+            (font_size * max_dim / text_w).floor
+          end
+
+          def generate_stamp_page(stamps, page_w, page_h)
+            ::Prawn::Document.new(page_size: [page_w, page_h], margin: 0) { |pdf|
+              stamps.each do |stamp|
+                if stamp[:text]
+                  render_text_stamp(pdf, stamp)
+                else
+                  render_image_stamp(pdf, stamp)
+                end
+              end
+            }.render
+          end
+
+          def image_dimensions(stamp, pdf)
+            img_w = stamp[:width]
+            img_h = stamp[:height]
+
+            unless img_h
+              _, info = pdf.build_image_object(File.open(stamp[:image], "rb"))
+              native_w = info.width.to_f
+              native_h = info.height.to_f
+              img_h = (img_w.to_f / native_w * native_h).round
+            end
+
+            [img_w, img_h]
+          end
+
+          def render_image_stamp(pdf, stamp)
+            page_w = pdf.bounds.width
+            page_h = pdf.bounds.height
+            img_w, img_h = image_dimensions(stamp, pdf)
+
+            x, y = Watermarker.calculate_position(
+              stamp[:position], page_w, page_h, img_w, img_h,
+              stamp[:offset_x], stamp[:offset_y]
+            )
+
+            # calculate_position returns bottom-left coordinates, but
+            # Prawn's image at: expects the top-left corner
+            y += img_h
+
+            image_opts = { at: [x, y], width: img_w }
+            image_opts[:height] = img_h if stamp[:height]
+
+            pdf.transparent(stamp[:opacity]) do
+              pdf.image stamp[:image], **image_opts
+            end
+          end
+
+          def render_text_stamp(pdf, stamp)
+            page_w = pdf.bounds.width
+            page_h = pdf.bounds.height
+
+            pdf.font(stamp[:font])
+            font_size = fit_font_size(stamp[:font_size], stamp[:text], pdf, page_w, page_h)
+            text_w = pdf.width_of(stamp[:text], size: font_size)
+            text_h = font_size.to_f
+
+            rotation = stamp[:rotation] || 0
+            rot_w, rot_h = rotated_bounds(text_w, text_h, rotation)
+
+            x, y = Watermarker.calculate_position(
+              stamp[:position], page_w, page_h, rot_w, rot_h,
+              stamp[:offset_x], stamp[:offset_y]
+            )
+
+            cx = x + rot_w / 2.0
+            cy = y + rot_h / 2.0
+
+            pdf.transparent(stamp[:opacity]) do
+              pdf.rotate(rotation, origin: [cx, cy]) do
+                pdf.fill_color(stamp[:color])
+                pdf.draw_text(stamp[:text], at: [cx - text_w / 2.0, cy - text_h / 2.0], size: font_size)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docpdf/adapters/stampers/hexapdf.rb

@@ -0,0 +1,127 @@
+require "hexapdf"
+require_relative "base"
+
+module DocPDF
+  module Adapters
+    module Stampers
+      class Hexapdf < Base
+        class << self
+          def stamp(data, stamps, page_indices: nil)
+            doc = HexaPDF::Document.new(io: StringIO.new(data))
+            source_page = doc.pages[0]
+            page_w = source_page.box.width
+            page_h = source_page.box.height
+
+            stamp_page_data = generate_stamp_page(stamps, page_w, page_h)
+            stamp_doc = HexaPDF::Document.new(io: StringIO.new(stamp_page_data))
+            stamp_form = doc.import(stamp_doc.pages[0].to_form_xobject)
+
+            doc.pages.each_with_index do |page, idx|
+              page.canvas(type: :overlay).xobject(stamp_form, at: [0, 0]) if page_indices.nil? || page_indices.include?(idx)
+            end
+
+            write_to_string(doc)
+          rescue HexaPDF::Error => e
+            raise ConversionError, "HexaPDF failed to stamp PDF: #{e.message}"
+          end
+
+          private
+
+          def fit_font_size(font_size, glyph_units, page_w, page_h)
+            max_dim = [page_w, page_h].max * 0.9
+            text_w = glyph_units * font_size / 1000.0
+            return font_size if text_w <= max_dim
+
+            (max_dim * 1000.0 / glyph_units).floor
+          end
+
+          def generate_stamp_page(stamps, page_w, page_h)
+            doc = HexaPDF::Document.new
+            page = doc.pages.add([0, 0, page_w, page_h])
+            canvas = page.canvas
+
+            stamps.each do |stamp|
+              if stamp[:text]
+                render_text_stamp(canvas, page, stamp, doc)
+              else
+                render_image_stamp(canvas, page, stamp, doc)
+              end
+            end
+
+            write_to_string(doc)
+          end
+
+          def image_dimensions(stamp, doc)
+            img_w = stamp[:width]
+            img_h = stamp[:height]
+
+            unless img_h
+              image = doc.images.add(File.open(stamp[:image], "rb"))
+              native_w = image.width.to_f
+              native_h = image.height.to_f
+              img_h = (img_w.to_f / native_w * native_h).round
+            end
+
+            [img_w, img_h]
+          end
+
+          def render_image_stamp(canvas, page, stamp, doc)
+            page_w = page.box.width
+            page_h = page.box.height
+            img_w, img_h = image_dimensions(stamp, doc)
+
+            x, y = Watermarker.calculate_position(
+              stamp[:position], page_w, page_h, img_w, img_h,
+              stamp[:offset_x], stamp[:offset_y]
+            )
+
+            image_opts = { at: [x, y], width: img_w }
+            image_opts[:height] = img_h if stamp[:height]
+
+            canvas.opacity(fill_alpha: stamp[:opacity]) do
+              canvas.image(File.open(stamp[:image], "rb"), **image_opts)
+            end
+          end
+
+          def render_text_stamp(canvas, page, stamp, doc)
+            page_w = page.box.width
+            page_h = page.box.height
+
+            font = doc.fonts.add(stamp[:font])
+            glyph_units = font.decode_utf8(stamp[:text]).sum { |g| g.width }
+            font_size = fit_font_size(stamp[:font_size], glyph_units, page_w, page_h)
+            text_w = glyph_units * font_size / 1000.0
+            text_h = font_size.to_f
+
+            rotation = stamp[:rotation] || 0
+            rot_w, rot_h = rotated_bounds(text_w, text_h, rotation)
+
+            x, y = Watermarker.calculate_position(
+              stamp[:position], page_w, page_h, rot_w, rot_h,
+              stamp[:offset_x], stamp[:offset_y]
+            )
+
+            cx = x + rot_w / 2.0
+            cy = y + rot_h / 2.0
+
+            canvas.opacity(fill_alpha: stamp[:opacity]) do
+              canvas.save_graphics_state do
+                canvas.translate(cx, cy)
+                canvas.rotate(rotation) if rotation != 0
+                canvas.font(stamp[:font], size: font_size)
+                canvas.fill_color(stamp[:color])
+                canvas.text(stamp[:text], at: [-text_w / 2.0, -text_h / 2.0])
+              end
+            end
+          end
+
+          def write_to_string(doc)
+            io = StringIO.new
+            doc.write(io)
+            io.string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docpdf/configuration.rb

@@ -0,0 +1,31 @@
+module DocPDF
+  class Configuration
+    attr_accessor :soffice_path,
+                  :stamper,
+                  :page_size,
+                  :text_options,
+                  :watermark_options
+
+    TEXT_DEFAULTS = {
+      font: "Courier",
+      font_size: 10,
+      margins: [50, 50, 50, 50],
+      color: "333333",
+    }.freeze
+
+    WATERMARK_DEFAULTS = {
+      font: "Helvetica",
+      font_size: 72,
+      color: "AAAAAA",
+      rotation: 45,
+    }.freeze
+
+    def initialize
+      @soffice_path      = "soffice"
+      @stamper            = nil
+      @page_size          = "LETTER"
+      @text_options       = TEXT_DEFAULTS.dup
+      @watermark_options  = WATERMARK_DEFAULTS.dup
+    end
+  end
+end

data/lib/docpdf/converter.rb

@@ -0,0 +1,28 @@
+module DocPDF
+  class Converter
+    class << self
+      def call(source = nil, **options)
+        new(source, **options).call
+      end
+    end
+
+    def initialize(source = nil, **options)
+      @input = InputNormalizer.new(source, **options.slice(:io, :data, :filename, :mime_type))
+    end
+
+    def call
+      data = ConverterResolver.resolve(@input.mime_type).convert(@input.data, @input.source_filename)
+      filename = build_filename(@input.filename)
+      Result.new(data: data, filename: filename)
+    end
+
+    private
+
+    def build_filename(original)
+      return "converted.pdf" unless original
+
+      base = File.basename(original, File.extname(original))
+      "#{base}.pdf"
+    end
+  end
+end

data/lib/docpdf/converter_resolver.rb

@@ -0,0 +1,77 @@
+module DocPDF
+  class ConverterResolver
+    @adapters = []
+
+    class << self
+      def register(name, require_name: nil, mime_types:, loader:)
+        @adapters << { name: name.to_sym, require_name: require_name, mime_types: mime_types, loader: loader }
+      end
+
+      def resolve(mime_type)
+        @adapters.each do |entry|
+          next unless entry[:mime_types].include?(mime_type)
+          require entry[:require_name] if entry[:require_name]
+          return entry[:loader].call
+        rescue LoadError
+          next
+        end
+        resolve_fallback
+      end
+
+      private
+
+      def resolve_fallback
+        entry = @adapters.find { |e| e[:name] == :fallback }
+        raise AdapterNotFoundError, "No converter found and no fallback registered" unless entry
+        entry[:loader].call
+      end
+    end
+
+    # Registration order determines priority for shared mime types
+    register :passthrough,
+      mime_types: %w[application/pdf],
+      loader: -> { require "docpdf/adapters/converters/passthrough"; Adapters::Converters::Passthrough }
+
+    register :soffice,
+      mime_types: %w[
+        application/msword
+        application/vnd.openxmlformats-officedocument.wordprocessingml.document
+        application/vnd.ms-excel
+        application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+        application/vnd.ms-powerpoint
+        application/vnd.openxmlformats-officedocument.presentationml.presentation
+        application/vnd.oasis.opendocument.text
+        application/vnd.oasis.opendocument.spreadsheet
+        application/vnd.oasis.opendocument.presentation
+        text/csv
+        text/html
+        text/rtf
+        application/rtf
+      ],
+      loader: -> { require "docpdf/adapters/converters/soffice"; Adapters::Converters::Soffice }
+
+    register :prawn,
+      require_name: "prawn",
+      mime_types: %w[text/plain],
+      loader: -> { require "docpdf/adapters/converters/prawn"; Adapters::Converters::Prawn }
+
+    register :hexapdf,
+      require_name: "hexapdf",
+      mime_types: %w[text/plain],
+      loader: -> { require "docpdf/adapters/converters/hexapdf"; Adapters::Converters::Hexapdf }
+
+    register :rmagick,
+      require_name: "rmagick",
+      mime_types: %w[image/jpeg image/png image/heic image/heif image/webp],
+      loader: -> { require "docpdf/adapters/converters/rmagick"; Adapters::Converters::Rmagick }
+
+    register :mini_magick,
+      require_name: "mini_magick",
+      mime_types: %w[image/jpeg image/png image/heic image/heif image/webp],
+      loader: -> { require "docpdf/adapters/converters/mini_magick"; Adapters::Converters::MiniMagick }
+
+    register :fallback,
+      mime_types: [],
+      loader: -> { require "docpdf/adapters/converters/fallback"; Adapters::Converters::Fallback }
+  end
+end

data/lib/docpdf/errors.rb

@@ -0,0 +1,6 @@
+module DocPDF
+  class Error < StandardError; end
+  class ConversionError < Error; end
+  class SofficeNotFoundError < Error; end
+  class AdapterNotFoundError < Error; end
+end

data/lib/docpdf/input_normalizer.rb

@@ -0,0 +1,76 @@
+module DocPDF
+  class InputNormalizer
+    attr_reader :data, :filename, :source_filename, :mime_type
+
+    def initialize(source = nil, io: nil, data: nil, filename: nil, mime_type: nil)
+      @data, source_filename, detected_mime = extract(source, io, data)
+
+      # MIME detection uses the source's original filename, not the user's
+      # display-name override, unless the source has no filename at all
+      # (e.g., raw data: with a filename: hint).
+      @source_filename = source_filename
+      @filename = filename || source_filename
+      @mime_type = mime_type || detected_mime || MimeDetector.detect(source_filename || filename)
+    end
+
+    private
+
+    def extract(source, io, data)
+      case source
+      when Pathname                           then extract_from_pathname(source)
+      when String                             then extract_from_string(source)
+      when ->(s) { s.respond_to?(:read) }     then extract_from_io(source)
+      when ->(s) { s.respond_to?(:download) } then extract_from_active_storage(source)
+      when ->(s) { s.respond_to?(:data) }     then extract_from_data_wrapper(source)
+      when nil                                then extract_from_kwargs(io, data)
+      else
+        raise ArgumentError, "Provide a file path, IO object, io:, or data:"
+      end
+    end
+
+    def extract_filename(source, method)
+      source.respond_to?(method) ? source.send(method) : nil
+    end
+
+    def extract_from_active_storage(source)
+      blob = source.respond_to?(:blob) ? source.blob : nil
+      [source.download, blob&.filename&.to_s, blob&.content_type]
+    end
+
+    def extract_from_data_wrapper(source)
+      source_filename = (source.respond_to?(:name) && source.name) || nil
+      detected_mime = source.respond_to?(:mime_type) ? source.mime_type : nil
+      [source.data, source_filename, detected_mime]
+    end
+
+    def extract_from_io(source)
+      [source.read, extract_filename(source, :original_filename), nil]
+    end
+
+    def extract_from_kwargs(io, data)
+      if io
+        [io.read, extract_filename(io, :original_filename), nil]
+      elsif data
+        [data, nil, nil]
+      else
+        raise ArgumentError, "Provide a file path, IO object, io:, or data:"
+      end
+    end
+
+    def extract_from_pathname(source)
+      [File.binread(source.to_s), File.basename(source.to_s), nil]
+    end
+
+    def extract_from_string(source)
+      if file_path?(source)
+        [File.binread(source), File.basename(source), nil]
+      else
+        [source, nil, nil]
+      end
+    end
+
+    def file_path?(string)
+      !string.match?(/[\x00-\x08]/) && File.exist?(string)
+    end
+  end
+end

data/lib/docpdf/mime_detector.rb

@@ -0,0 +1,36 @@
+module DocPDF
+  class MimeDetector
+    EXTENSION_MAP = {
+      ".pdf"  => "application/pdf",
+      ".doc"  => "application/msword",
+      ".docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".xls"  => "application/vnd.ms-excel",
+      ".xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".ppt"  => "application/vnd.ms-powerpoint",
+      ".pptx" => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      ".odt"  => "application/vnd.oasis.opendocument.text",
+      ".ods"  => "application/vnd.oasis.opendocument.spreadsheet",
+      ".odp"  => "application/vnd.oasis.opendocument.presentation",
+      ".csv"  => "text/csv",
+      ".html" => "text/html",
+      ".htm"  => "text/html",
+      ".txt"  => "text/plain",
+      ".rtf"  => "text/rtf",
+      ".jpg"  => "image/jpeg",
+      ".jpeg" => "image/jpeg",
+      ".png"  => "image/png",
+      ".heic" => "image/heic",
+      ".heif" => "image/heif",
+      ".webp" => "image/webp",
+    }.freeze
+
+    class << self
+      def detect(filename)
+        return nil if filename.nil?
+
+        ext = File.extname(filename).downcase
+        EXTENSION_MAP[ext]
+      end
+    end
+  end
+end

data/lib/docpdf/result.rb

@@ -0,0 +1,14 @@
+module DocPDF
+  class Result
+    attr_reader :data, :filename
+
+    def initialize(data:, filename: nil)
+      @data = data
+      @filename = filename
+    end
+
+    def watermark(*stamps, **options)
+      DocPDF.watermark(self, *stamps, **options)
+    end
+  end
+end

data/lib/docpdf/stamper_resolver.rb

@@ -0,0 +1,43 @@
+module DocPDF
+  class StamperResolver
+    @adapters = []
+
+    class << self
+      def register(name, loader:)
+        @adapters << { name: name.to_sym, loader: loader }
+      end
+
+      def resolve
+        configured = DocPDF.configuration.stamper
+        if configured
+          entry = @adapters.find { |e| e[:name] == configured }
+          raise AdapterNotFoundError, "Unknown stamper: #{configured}" unless entry
+          begin
+            entry[:loader].call
+          rescue LoadError => e
+            raise AdapterNotFoundError, "Stamper '#{configured}' requires gems that are not available: #{e.message}"
+          end
+        else
+          auto_detect
+        end
+      end
+
+      private
+
+      def auto_detect
+        @adapters.each do |entry|
+          return entry[:loader].call
+        rescue LoadError
+          next
+        end
+        raise AdapterNotFoundError, "No stamper available. Add 'hexapdf' or 'combine_pdf' (with 'prawn') to your Gemfile."
+      end
+    end
+
+    register :hexapdf,
+      loader: -> { require "hexapdf"; require "docpdf/adapters/stampers/hexapdf"; Adapters::Stampers::Hexapdf }
+
+    register :combine_pdf,
+      loader: -> { require "combine_pdf"; require "prawn"; require "docpdf/adapters/stampers/combine_pdf"; Adapters::Stampers::CombinePdf }
+  end
+end

data/lib/docpdf/version.rb

@@ -0,0 +1,3 @@
+module DocPDF
+  VERSION = "0.1.0"
+end