pdf 0.1.0 → 0.1.1

data/lib/pdf/builders/footer_builder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Builders
+    class FooterBuilder
+      include DynamicComponents
+
+      attr_reader :blueprint
+
+      def initialize
+        @blueprint = Blueprint.new
+      end
+
+      def text(source, **options)
+        @blueprint.add(:footer_text, source, **options)
+      end
+
+      # Page number is handled by FooterEvaluator, not as a component
+      def page_number(**options)
+        @blueprint.add(:page_number, **options)
+      end
+    end
+  end
+end

data/lib/pdf/builders/header_builder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Builders
+    class HeaderBuilder
+      include DynamicComponents
+
+      attr_reader :blueprint
+
+      def initialize
+        @blueprint = Blueprint.new
+      end
+
+      def logo(path, **options)
+        @blueprint.add(:logo, path, **options)
+      end
+
+      def qr_code(**options)
+        @blueprint.add(:qr_code, **options)
+      end
+
+      def context(source, **options)
+        @blueprint.add(:context, source, **options)
+      end
+
+      def text(value, **options)
+        @blueprint.add(:header_text, value, **options)
+      end
+    end
+  end
+end

data/lib/pdf/component.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pdf
+  class Component
+    attr_reader :pdf
+
+    def initialize(pdf)
+      @pdf = pdf
+    end
+
+    def render(...)
+      raise NotImplementedError, "#{self.class}#render not implemented"
+    end
+
+    private
+
+    # Primitive helpers (delegate to pdf)
+
+    def text(content, **options)
+      @pdf.text content.to_s, **options
+    end
+
+    def move_down(amount)
+      @pdf.move_down amount
+    end
+
+    def stroke_horizontal_rule
+      @pdf.stroke_horizontal_rule
+    end
+
+    def bounding_box(point, **options, &block)
+      @pdf.bounding_box(point, **options, &block)
+    end
+
+    def cursor
+      @pdf.cursor
+    end
+
+    def bounds
+      @pdf.bounds
+    end
+  end
+end

data/lib/pdf/components/alert.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Alert < Component
+      COLORS = {
+        "green"  => { bg: "C8E6C9", text: "2E7D32", border: "4CAF50" },
+        "orange" => { bg: "FFE0B2", text: "E65100", border: "FF9800" },
+        "red"    => { bg: "FFCDD2", text: "C62828", border: "F44336" },
+        "blue"   => { bg: "E1F5FE", text: "0277BD", border: "2196F3" }
+      }.freeze
+
+      def render(title:, description: nil, color: "blue", **_options)
+        scheme = COLORS[color.to_s] || COLORS["blue"]
+
+        title_h = 20
+        desc_h = description ? (@pdf.height_of(description.to_s, width: bounds.width - 20, size: 10) + 10) : 0
+        total_h = title_h + desc_h + 6
+
+        bounding_box([bounds.left, cursor], width: bounds.width, height: total_h) do
+          @pdf.stroke_color scheme[:border]
+          @pdf.line_width 0.5
+          @pdf.fill_color scheme[:bg]
+          @pdf.fill_and_stroke_rounded_rectangle [bounds.left, bounds.top], bounds.width, bounds.height, 5
+
+          @pdf.fill_color scheme[:text]
+
+          y = bounds.top - 10
+          @pdf.text_box title.to_s, at: [10, y], width: bounds.width - 20, size: 11, style: :bold
+
+          if description
+            y -= 18
+            @pdf.text_box description.to_s, at: [10, y], width: bounds.width - 20, size: 10
+          end
+        end
+
+        @pdf.fill_color "000000"
+        move_down 15
+      end
+    end
+  end
+end

data/lib/pdf/components/context.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Context < Component
+      def render(lines, label: "CONTEXT", **_options)
+        raise ArgumentError, "Context lines cannot be nil" if lines.nil?
+        return if lines.empty?
+
+        text label, size: 12, style: :bold
+        lines.each { |line| text line.to_s, size: 10 }
+        move_down 20
+      end
+    end
+  end
+end

data/lib/pdf/components/date.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Date < Component
+      DEFAULT_FORMAT = "%B %d, %Y"
+
+      def render(value, format: DEFAULT_FORMAT, size: 10, align: :right, **options)
+        formatted = format_date(value, format)
+        text formatted, size: size, align: align, **options
+        move_down 5
+      end
+
+      private
+
+      def format_date(value, format)
+        case value
+        when ::Date, ::Time, ::DateTime
+          value.strftime(format)
+        when String
+          value
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/pdf/components/heading.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Heading < Component
+      def render(content, size: 14, **options)
+        text content, size: size, style: :bold, **options
+        move_down 8
+      end
+    end
+  end
+end

data/lib/pdf/components/hr.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Hr < Component
+      def render(**_options)
+        stroke_horizontal_rule
+        move_down 10
+      end
+    end
+  end
+end

data/lib/pdf/components/logo.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Logo < Component
+      def render(path, width: 120, height: nil, **_options)
+        raise Pdf::FileNotFoundError, "Logo not found: #{path}" unless File.exist?(path)
+
+        opts = { width: width }
+        opts[:height] = height if height
+        @pdf.image path, **opts
+      end
+    end
+  end
+end

data/lib/pdf/components/paragraph.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Paragraph < Component
+      def render(content, size: 10, leading: 3, **options)
+        text content, size: size, leading: leading, **options
+        move_down 10
+      end
+    end
+  end
+end

data/lib/pdf/components/qr_code.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "rqrcode"
+
+module Pdf
+  module Components
+    class QrCode < Component
+      def render(data:, size: 80, position: :right, **_options)
+        png_data = generate_qr_png(data, size)
+
+        if position == :right
+          @pdf.float do
+            bounding_box([bounds.width - size, cursor], width: size) do
+              @pdf.image StringIO.new(png_data), width: size, height: size
+            end
+          end
+        else
+          @pdf.image StringIO.new(png_data), width: size, height: size
+        end
+      end
+
+      private
+
+      def generate_qr_png(data, size)
+        qrcode = RQRCode::QRCode.new(data.to_s)
+        png = qrcode.as_png(
+          bit_depth: 1,
+          border_modules: 2,
+          color_mode: ChunkyPNG::COLOR_GRAYSCALE,
+          color: "black",
+          fill: "white",
+          size: size * 4  # Higher resolution for quality
+        )
+        png.to_s
+      end
+    end
+  end
+end

data/lib/pdf/components/spacer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Spacer < Component
+      def render(amount: 20, **_options)
+        move_down amount
+      end
+    end
+  end
+end

data/lib/pdf/components/span.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Span < Component
+      def render(content, size: 10, **options)
+        text content, size: size, **options
+        move_down 3
+      end
+    end
+  end
+end

data/lib/pdf/components/subtitle.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Subtitle < Component
+      def render(content, size: 16, **options)
+        text content, size: size, **options
+        move_down 5
+      end
+    end
+  end
+end

data/lib/pdf/components/table.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Table < Component
+      def render(headers:, rows:, widths: nil, **_options)
+        return if rows.empty? && headers.empty?
+
+        data = [headers] + rows
+
+        opts = {
+          header: true,
+          width: bounds.width,
+          cell_style: { borders: [:top, :bottom, :left, :right], padding: [4, 6], size: 8 }
+        }
+
+        # Only set column_widths if explicit numeric values (not percentages)
+        # For percentages, let prawn auto-distribute based on content
+        if widths && !widths.any? { |w| w.is_a?(String) && w.end_with?("%") }
+          opts[:column_widths] = calculate_widths(widths)
+        end
+
+        @pdf.table(data, **opts) do
+          row(0).background_color = "333333"
+          row(0).text_color = "FFFFFF"
+          row(0).font_style = :bold
+
+          (1..row_length - 1).each do |i|
+            row(i).background_color = i.odd? ? "F5F5F5" : "FFFFFF"
+          end
+        end
+
+        move_down 15
+      end
+
+      private
+
+      def calculate_widths(widths)
+        widths.map do |w|
+          case w
+          when Numeric then w.to_f
+          else raise ArgumentError, "Invalid width: #{w}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdf/components/title.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pdf
+  module Components
+    class Title < Component
+      def render(content, size: 20, **options)
+        text content, size: size, style: :bold, **options
+        move_down 10
+      end
+    end
+  end
+end

data/lib/pdf/content_evaluator.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Pdf
+  class ContentEvaluator
+    def initialize(context, renderer)
+      @context = context
+      @renderer = renderer
+      @resolver = Resolver.new(context)
+    end
+
+    def evaluate(blueprint)
+      blueprint.elements.each { |el| evaluate_element(el) }
+    end
+
+    private
+
+    def evaluate_element(element)
+      type = element[:type]
+      args = element[:args]
+      options = element[:options]
+
+      case type
+      when :title, :subtitle, :heading, :paragraph, :span
+        render_text_component(type, args.first, options)
+
+      when :date
+        render_date(args.first, options)
+
+      when :hr
+        component(:hr).render(**options)
+
+      when :spacer
+        component(:spacer).render(**options)
+
+      when :alert
+        render_alert(args.first, options)
+
+      when :table
+        render_table(args.first, options)
+
+      when :section
+        render_section(args.first, options)
+
+      when :each
+        render_each(args.first, options)
+
+      when :partial
+        @context.send(args.first, @renderer)
+
+      when :page_break
+        @renderer.start_new_page
+
+      when :page_break_if
+        threshold = options[:threshold]
+        @renderer.start_new_page if @renderer.cursor < (@renderer.bounds.height * threshold)
+
+      when :render_if
+        render_conditional(args.first, options[:nested], truthy: true)
+
+      when :render_unless
+        render_conditional(args.first, options[:nested], truthy: false)
+
+      when :raw
+        # Escape hatch for direct Prawn access
+        block = options[:block]
+        @renderer.raw(&block) if block
+
+      else
+        # Try registered component
+        render_custom_component(type, args, options)
+      end
+    end
+
+    def render_text_component(type, source, options)
+      content = @resolver.resolve(source)
+      component(type).render(content, **options)
+    end
+
+    def render_date(source, options)
+      value = @resolver.resolve(source)
+      component(:date).render(value, **options)
+    end
+
+    def render_alert(source, options)
+      # Handle inline alert (title/description passed as options)
+      if source.nil? && (options[:title] || options[:description])
+        component(:alert).render(
+          title: options[:title],
+          description: options[:description],
+          color: options[:color] || "blue"
+        )
+        return
+      end
+
+      data = @resolver.resolve(source)
+
+      if data.is_a?(Hash)
+        component(:alert).render(
+          title: data[:title] || data["title"],
+          description: data[:description] || data["description"] || data[:subtitle] || data["subtitle"],
+          color: data[:color] || data["color"] || options[:color] || "blue"
+        )
+      else
+        component(:alert).render(title: data.to_s, color: options[:color] || "blue")
+      end
+    end
+
+    def render_table(source, options)
+      data = @resolver.resolve(source)
+      columns = options[:columns]
+      widths = options[:widths]
+
+      headers, rows = extract_table_data(data, columns, options)
+      component(:table).render(headers: headers, rows: rows, widths: widths)
+    end
+
+    def extract_table_data(data, columns, options)
+      if data.is_a?(Array) && data.first.is_a?(Hash) && columns
+        headers = columns.map { |c| c.is_a?(Hash) ? c[:label] : c.to_s.capitalize }
+        rows = data.map do |row|
+          columns.map do |col|
+            key = col.is_a?(Hash) ? col[:key] : col
+            row[key] || row[key.to_s] || "-"
+          end
+        end
+        [headers, rows]
+
+      elsif data.is_a?(Hash) && data[:headers] && data[:rows]
+        [data[:headers], data[:rows]]
+
+      elsif data.is_a?(Array) && data.first.is_a?(Array)
+        if options[:headers]
+          [options[:headers], data]
+        else
+          [data.first, data[1..]]
+        end
+
+      else
+        [["Key", "Value"], data.to_a]
+      end
+    end
+
+    def render_section(title, options)
+      component(:heading).render(title, size: 12)
+      evaluate(options[:nested]) if options[:nested]
+    end
+
+    def render_each(source, options)
+      collection = @resolver.resolve(source)
+      block = options[:block]
+      return if collection.nil? || collection.empty?
+
+      collection.each do |item|
+        item_context = EachItemContext.new(@context, item)
+        sub_evaluator = self.class.new(item_context, @renderer)
+
+        builder = Builders::ContentBuilder.new
+        builder.instance_exec(item, &block)
+        sub_evaluator.evaluate(builder.blueprint)
+      end
+    end
+
+    def render_conditional(condition, nested_blueprint, truthy:)
+      return unless nested_blueprint
+
+      condition_value = @resolver.resolve(condition)
+      should_render = truthy ? condition_value : !condition_value
+
+      evaluate(nested_blueprint) if should_render
+    end
+
+    def render_custom_component(type, args, options)
+      return unless Pdf.component_registered?(type)
+
+      comp = component(type)
+      if args.empty?
+        comp.render(**options)
+      else
+        resolved_args = args.map { |a| @resolver.resolve(a) }
+        comp.render(*resolved_args, **options)
+      end
+    end
+
+    def component(type)
+      Pdf.component(type).new(@renderer.pdf)
+    end
+  end
+
+  # Context wrapper for each iteration
+  class EachItemContext
+    def initialize(parent, item)
+      @parent = parent
+      @item = item
+    end
+
+    def data
+      @parent.data
+    end
+
+    attr_reader :item
+
+    def method_missing(method, *args, &block)
+      if @item.respond_to?(method)
+        @item.send(method, *args, &block)
+      elsif @item.is_a?(Hash) && (@item.key?(method) || @item.key?(method.to_s))
+        @item[method] || @item[method.to_s]
+      else
+        @parent.send(method, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @item.respond_to?(method) ||
+        (@item.is_a?(Hash) && (@item.key?(method) || @item.key?(method.to_s))) ||
+        @parent.respond_to?(method, include_private)
+    end
+  end
+end

data/lib/pdf/dynamic_components.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pdf
+  module DynamicComponents
+    def method_missing(name, *args, **options, &block)
+      if Pdf.component_registered?(name)
+        @blueprint.add(name, *args, **options, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      Pdf.component_registered?(name) || super
+    end
+  end
+end

data/lib/pdf/footer_evaluator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Pdf
+  class FooterEvaluator
+    def initialize(context, renderer)
+      @context = context
+      @renderer = renderer
+      @resolver = Resolver.new(context)
+    end
+
+    def setup(blueprint)
+      texts = []
+      page_number_opts = nil
+
+      blueprint.elements.each do |el|
+        case el[:type]
+        when :footer_text
+          content = @resolver.resolve(el[:args].first)
+          texts << { text: content, size: el[:options][:size] || 8 }
+
+        when :page_number
+          page_number_opts = el[:options]
+        end
+      end
+
+      @renderer.setup_footer do |pdf|
+        render_footer_content(pdf, texts, page_number_opts)
+      end
+    end
+
+    private
+
+    def render_footer_content(pdf, texts, page_number_opts)
+      footer_y = 24
+
+      # Text lines (left-aligned)
+      unless texts.empty?
+        pdf.repeat(:all) do
+          pdf.canvas do
+            y = footer_y
+            texts.each do |t|
+              pdf.draw_text t[:text].to_s, at: [36, y], size: t[:size]
+              y -= 12
+            end
+          end
+        end
+      end
+
+      # Page numbers (right-aligned)
+      return unless page_number_opts
+
+      position = page_number_opts[:position] || :right
+      size = page_number_opts[:size] || 8
+      fmt = page_number_opts[:format] || "Page %<page>d / %<total>d"
+
+      pdf.repeat(:all, dynamic: true) do
+        pdf.canvas do
+          page_str = format(fmt, page: pdf.page_number, total: pdf.page_count)
+          text_w = pdf.width_of(page_str, size: size)
+          x = position == :right ? pdf.bounds.absolute_right - 36 - text_w : 36
+          pdf.draw_text page_str, at: [x, footer_y], size: size
+        end
+      end
+    end
+  end
+end