stationery 0.1.0

data/lib/stationery/layout/table/widths.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Layout
+    class Table < Node
+      # Column widths from a spec (points, a fraction of the table, or nil for
+      # flexible), each column's natural and minimum width, and a target width.
+      module Widths
+        module_function
+
+        def resolve(spec:, natural:, min:, target:)
+          widths = spec.map { |s| fixed(s, target) }
+          flexible = widths.each_index.select { |i| widths[i].nil? }
+          return widths if flexible.empty?
+
+          remaining = [target - widths.compact.sum, 0].max
+          shares = distribute(flexible.map { |i| natural[i] }, flexible.map { |i| min[i] }, remaining)
+          flexible.zip(shares).each { |i, width| widths[i] = width }
+          widths
+        end
+
+        def fixed(spec, target)
+          case spec
+          when nil then nil
+          when Float then spec <= 1 ? target * spec : spec
+          else spec
+          end
+        end
+
+        def distribute(natural, min, remaining)
+          total = natural.sum
+          return grow(natural, remaining, total) if total <= remaining
+          return shrink(natural, min, total - remaining) if min.sum <= remaining
+
+          min.map { |m| min.sum.zero? ? remaining.fdiv(min.size) : m * remaining.fdiv(min.sum) }
+        end
+
+        def grow(natural, remaining, total)
+          extra = remaining - total
+          return natural.map { |n| n + extra.fdiv(natural.size) } if total.zero?
+
+          natural.map { |n| n + (extra * n.fdiv(total)) }
+        end
+
+        def shrink(natural, min, excess)
+          slack = natural.zip(min).map { |n, m| n - m }
+          total = slack.sum
+          natural.zip(slack).map { |n, s| n - (excess * s.fdiv(total)) }
+        end
+      end
+    end
+  end
+end

data/lib/stationery/layout/table.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Layout
+    # Rows of cells with column widths, per-cell styling through selections,
+    # header rows repeated after a page break, and splitting between rows.
+    class Table < Node
+      DEFAULT_CELL = { padding: 5, borders: %i[top right bottom left], border_width: 0.5,
+                       border_color: "#000000" }.freeze
+
+      def initialize(rows, context:, widths: nil, width: :auto, header: false, cell: {})
+        super()
+        @context = context
+        @widths = widths
+        @width = width
+        @header = header == true ? 1 : (header || 0).to_i
+        defaults = DEFAULT_CELL.merge(cell)
+        @cells = rows.map { |row| row.map { |content| content.is_a?(Cell) ? content : Cell.new(content, defaults) } }
+        yield self if block_given?
+      end
+
+      def row_count = @cells.size
+      def column_count = @cells.map(&:size).max || 0
+      def cell(row, column) = @cells.dig(row, column)
+
+      def rows(spec) = Selection.new(self, Selection.indexes(spec, row_count), (0...column_count).to_a)
+      alias row rows
+
+      def columns(spec) = Selection.new(self, (0...row_count).to_a, Selection.indexes(spec, column_count))
+      alias column columns
+
+      def cells = Selection.new(self, (0...row_count).to_a, (0...column_count).to_a)
+
+      def zebra(color:, from: 0, to: nil, every: 2)
+        (from..(to || (row_count - 1))).step(every) { |r| rows(r).background = color }
+        self
+      end
+
+      def splittable? = true
+
+      def natural_width = column_metric(:natural_width).sum
+      def min_width = column_metric(:min_width).sum
+
+      def fixed_width(available)
+        case @width
+        when :full then nil
+        when Numeric then [@width, available].min
+        else [column_widths(available).sum, available].min
+        end
+      end
+
+      def column_widths(available)
+        @column_widths ||= {}
+        @column_widths[available] ||= Widths.resolve(
+          spec: Array.new(column_count) { |i| @widths&.[](i) },
+          natural: column_metric(:natural_width), min: column_metric(:min_width), target: target(available)
+        )
+      end
+
+      def measure(width) = row_heights(width).sum
+
+      def paint(canvas, x, y, width, _height = nil, **)
+        widths = column_widths(width)
+        top = y
+        @cells.zip(row_heights(width)).each_with_index do |(row, height), row_index|
+          left = x
+          row.each_with_index do |cell, index|
+            cell.paint(canvas, @context, Rect.new(left, top, widths[index], height),
+                       last_column: index == row.size - 1, last_row: row_index == @cells.size - 1)
+            left += widths[index]
+          end
+          top += height
+        end
+      end
+
+      def split(width, height)
+        heights = row_heights(width)
+        used = heights.first(@header).sum
+        count = @header
+        count += 1 while count < row_count && used + heights[count] <= height + EPSILON && (used += heights[count])
+        return [self, nil] if count == row_count
+        return [nil, self] if count == @header
+
+        [with_rows(@cells.first(count)), with_rows(@cells.first(@header) + @cells.drop(count))]
+      end
+
+      private
+
+      def target(available)
+        case @width
+        when :full then available
+        when Numeric then [@width, available].min
+        else [natural_total, available].min
+        end
+      end
+
+      def natural_total
+        natural = column_metric(:natural_width)
+        Array.new(column_count) { |i| @widths&.[](i) || natural[i] }.sum
+      end
+
+      def column_metric(metric)
+        Array.new(column_count) do |c|
+          @cells.filter_map { |row| row[c]&.public_send(metric, @context) }.max || 0
+        end
+      end
+
+      def row_heights(width)
+        widths = column_widths(width)
+        @cells.map { |row| row.each_with_index.map { |cell, i| cell.measure(@context, widths[i]) }.max || 0 }
+      end
+
+      def with_rows(rows)
+        self.class.new(rows, context: @context, widths: @widths, width: @width, header: @header)
+      end
+    end
+  end
+end

data/lib/stationery/layout/text.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Layout
+    # A paragraph of styled runs. Splits between lines.
+    class Text < Node
+      attr_reader :runs
+
+      def initialize(runs, context:, align: :left, leading: 0, paragraph: nil)
+        super()
+        @runs = runs
+        @context = context
+        @align = align
+        @leading = leading
+        @paragraph = paragraph
+        @paragraphs = {}
+      end
+
+      def splittable? = true
+
+      def measure(width) = paragraph(width).height
+
+      def paint(canvas, x, y, width, _height = nil, **)
+        paragraph(width).draw(canvas, x, y)
+      end
+
+      def split(width, height)
+        head, tail = paragraph(width).split(height)
+        [head && from(head), tail && from(tail)]
+      end
+
+      def fit(width, height, overflow:)
+        from(paragraph(width).fit(height, overflow:))
+      end
+
+      def natural_width
+        @natural_width ||= paragraph(Float::INFINITY).lines.map(&:width).max || 0
+      end
+
+      def min_width
+        @min_width ||= @runs.flat_map do |run|
+          font = @context.book.resolve(run.style).first
+          run.text.split(/[ \t\n]+/).map do |word|
+            font.width_of(word, run.style.render_size, letter_spacing: run.style.letter_spacing)
+          end
+        end.max || 0
+      end
+
+      private
+
+      def paragraph(width)
+        @paragraph || (@paragraphs[width] ||= ::Stationery::Text::Paragraph.new(
+          @runs, book: @context.book, width:, align: @align, leading: @leading, fallback_style: @context.style
+        ))
+      end
+
+      def from(paragraph)
+        self.class.new(@runs, context: @context, align: @align, leading: @leading, paragraph:)
+      end
+    end
+  end
+end

data/lib/stationery/page.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Stationery
+  # One page: its size and margins, the drawing operators written to it, the
+  # resources those operators reference and its link annotations.
+  class Page
+    SIZES = {
+      a3: [841.89, 1190.55], a4: [595.28, 841.89], a5: [419.53, 595.28],
+      letter: [612, 792], legal: [612, 1008], tabloid: [792, 1224]
+    }.freeze
+
+    attr_reader :size, :margin, :content, :annotations, :resource_names
+
+    def initialize(size: :letter, layout: :portrait, margin: 0)
+      @size = dimensions(size)
+      @size = @size.reverse if layout.to_sym == :landscape
+      @margin = Geometry.box(margin)
+      @content = String.new(encoding: Encoding::BINARY)
+      @annotations = []
+      @resource_names = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def width = @size[0]
+    def height = @size[1]
+
+    def content_box
+      top, right, bottom, left = @margin
+      Rect.new(left, top, width - left - right, height - top - bottom)
+    end
+
+    def use(category, name)
+      names = @resource_names[category]
+      names << name unless names.include?(name)
+      name
+    end
+
+    private
+
+    def dimensions(size)
+      return size.map { |v| v } if size.is_a?(Array) && size.size == 2
+
+      SIZES.fetch(size.to_s.downcase.to_sym) do
+        raise ArgumentError, "unknown page size #{size.inspect} (use #{SIZES.keys.join(", ")} or [width, height])"
+      end
+    end
+  end
+end

data/lib/stationery/page_templates.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Stationery
+  # What a page template knows about the page it draws on.
+  PageInfo = Data.define(:number, :count, :width, :height, :margin, :content_box)
+
+  # Runs a document's page templates on every finished page.
+  class PageTemplates
+    def initialize(document, book:, resources:)
+      @document = document
+      @book = book
+      @resources = resources
+      @templates = document.class.config[:templates]
+    end
+
+    def apply(pages)
+      return if @templates.empty?
+
+      pages.each_with_index do |page, index|
+        info = PageInfo.new(index + 1, pages.size, page.width, page.height, page.margin, page.content_box)
+        @templates.each { |layer, block| draw(page, info, layer, block) }
+      end
+    end
+
+    private
+
+    def draw(page, info, layer, block)
+      builder = Builder.new(book: @book, text: @document.class.config[:text])
+      @document.build_with(builder) { @document.instance_exec(info, &block) }
+      mark = page.content.bytesize
+      box = page.content_box
+      builder.root.paint(Canvas.new(page, @resources), box.x, box.y, box.width)
+      page.content.prepend(page.content.slice!(mark..)) if layer == :background
+    end
+  end
+end

data/lib/stationery/pdf/assembler.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Stationery
+  module PDF
+    # Writes finished pages, their shared resources and document info as PDF.
+    class Assembler
+      def initialize(pages:, resources:, info: {})
+        @pages = pages
+        @resources = resources
+        @info = info
+      end
+
+      def render
+        writer = Writer.new
+        tree = writer.reserve
+        refs = @resources.build(writer)
+        kids = @pages.map { |page| write_page(writer, page, tree, refs) }
+        writer.set(tree, { Type: :Pages, Kids: kids, Count: kids.size })
+        root = writer.add({ Type: :Catalog, Pages: tree })
+        writer.render(root:, info: writer.add(info_dictionary))
+      end
+
+      private
+
+      def write_page(writer, page, tree, refs)
+        dictionary = {
+          Type: :Page, Parent: tree, MediaBox: [0, 0, *page.size],
+          Contents: writer.add(Stream.new(page.content)), Resources: page_resources(page, refs)
+        }
+        dictionary[:Annots] = page.annotations.map { |link| writer.add(annotation(link)) } if page.annotations.any?
+        writer.add(dictionary)
+      end
+
+      def page_resources(page, refs)
+        page.resource_names.to_h do |category, names|
+          [category, names.to_h { |name| [name, refs.fetch(category).fetch(name)] }]
+        end
+      end
+
+      def annotation(link)
+        { Type: :Annot, Subtype: :Link, Rect: link[:rect], Border: [0, 0, 0],
+          A: { Type: :Action, S: :URI, URI: link[:url].b } }
+      end
+
+      def info_dictionary
+        info = { Producer: "Stationery #{VERSION}" }.merge(@info.compact)
+        info = info.transform_values { |value| TextString.new(value.to_s) }
+        info[:CreationDate] = TextString.new(Time.now.utc.strftime("D:%Y%m%d%H%M%SZ"))
+        info
+      end
+    end
+  end
+end

data/lib/stationery/pdf/serializer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Stationery
+  module PDF
+    # Turns Ruby values into PDF object syntax.
+    #
+    # A plain String is always written as a literal byte string `( … )` — never
+    # re-encoded — so a URI stays the 7-bit ASCII the spec requires. Use
+    # TextString for human-readable text that may need UTF-16.
+    module Serializer
+      NAME_ESCAPE = %r{[^\x21-\x7E]|[#%()/<>\[\]{}]}n
+      LITERAL_ESCAPE = /[\\()\r]/n
+      UTF16_BOM = "\xFE\xFF".b
+
+      module_function
+
+      def dump(value)
+        case value
+        when Reference then "#{value.id} 0 R"
+        when Symbol then name(value)
+        when Hash then "<<#{value.map { |k, v| "#{name(k)} #{dump(v)}" }.join(" ")}>>"
+        when Array then "[#{value.map { |v| dump(v) }.join(" ")}]"
+        when HexString then "<#{value.bytes.unpack1("H*").upcase}>"
+        when TextString then text(value.value)
+        when String then literal(value)
+        when Integer, true, false then value.to_s
+        when Float then number(value)
+        when nil then "null"
+        else raise ArgumentError, "cannot serialize #{value.class} to PDF"
+        end
+      end
+
+      def name(value)
+        "/#{value.to_s.b.gsub(NAME_ESCAPE) { |c| format("#%02X", c.ord) }}"
+      end
+
+      def literal(value)
+        "(#{value.b.gsub(LITERAL_ESCAPE) { |c| c == "\r" ? "\\r" : "\\#{c}" }})"
+      end
+
+      def number(value)
+        return value.to_s if value.is_a?(Integer)
+
+        str = format("%.4f", value).sub(/\.?0+\z/, "")
+        str == "-0" ? "0" : str
+      end
+
+      def text(value)
+        value = value.to_s
+        return literal(value) if value.ascii_only?
+
+        dump(HexString.new(UTF16_BOM + value.encode(Encoding::UTF_16BE).b))
+      end
+    end
+  end
+end

data/lib/stationery/pdf/stream.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Stationery
+  module PDF
+    # A stream object. Data is Flate-compressed unless the dictionary already
+    # names a filter (JPEG's DCTDecode, or PNG data that is already zlib).
+    class Stream
+      attr_reader :dictionary, :data
+
+      def initialize(data, dictionary = {})
+        data = data.b
+        dictionary = dictionary.dup
+
+        unless dictionary.key?(:Filter)
+          data = Zlib::Deflate.deflate(data)
+          dictionary[:Filter] = :FlateDecode
+        end
+
+        dictionary[:Length] = data.bytesize
+        @data = data
+        @dictionary = dictionary
+      end
+    end
+  end
+end

data/lib/stationery/pdf/types.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Stationery
+  module PDF
+    # An indirect object reference: `12 0 R`.
+    Reference = Data.define(:id)
+
+    # Bytes written in hex form: `<48656C6C6F>`.
+    HexString = Data.define(:bytes)
+
+    # A human-readable string (document info, outline titles): written as a
+    # literal when ASCII, as UTF-16BE with a byte order mark otherwise.
+    TextString = Data.define(:value)
+  end
+end

data/lib/stationery/pdf/writer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+
+module Stationery
+  module PDF
+    # Collects numbered objects and writes them as a PDF file with a classic
+    # cross-reference table.
+    class Writer
+      HEADER = "%PDF-1.7\n%\xE2\xE3\xCF\xD3\n".b
+
+      def initialize
+        @objects = []
+      end
+
+      # Hands out a reference now and lets the object be set later, so a page
+      # can point at its parent before the page tree exists.
+      def reserve
+        @objects << nil
+        Reference.new(@objects.size)
+      end
+
+      def set(ref, value)
+        @objects[ref.id - 1] = value
+        ref
+      end
+
+      def add(value)
+        set(reserve, value)
+      end
+
+      def render(root:, info:)
+        out = HEADER.dup
+        offsets = @objects.each_with_index.map { |object, index| write_object(out, index + 1, object) }
+        xref = out.bytesize
+        id = HexString.new(Digest::MD5.digest(out))
+
+        out << "xref\n0 #{@objects.size + 1}\n0000000000 65535 f \n"
+        offsets.each { |offset| out << format("%010d 00000 n \n", offset) }
+        out << "trailer\n" << Serializer.dump({ Size: @objects.size + 1, Root: root, Info: info, ID: [id, id] })
+        out << "\nstartxref\n#{xref}\n%%EOF\n"
+      end
+
+      private
+
+      def write_object(out, number, object)
+        offset = out.bytesize
+        out << "#{number} 0 obj\n"
+        if object.is_a?(Stream)
+          out << Serializer.dump(object.dictionary) << "\nstream\n" << object.data << "\nendstream"
+        else
+          out << Serializer.dump(object)
+        end
+        out << "\nendobj\n"
+        offset
+      end
+    end
+  end
+end

data/lib/stationery/rails.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "stationery"
+
+module Stationery
+  # Controller helper:
+  #
+  #   def show
+  #     send_pdf InvoicePdf.new(@invoice), filename: "invoice.pdf"
+  #   end
+  module Rails
+    def send_pdf(document, disposition: "inline", type: "application/pdf", **)
+      send_data(document.to_pdf, type:, disposition:, **)
+    end
+  end
+end
+
+if defined?(ActiveSupport) && ActiveSupport.respond_to?(:on_load)
+  ActiveSupport.on_load(:action_controller) { include Stationery::Rails }
+end

data/lib/stationery/resources.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Stationery
+  # Document-wide names for fonts, images and graphics states, so each is
+  # embedded once however many pages use it.
+  class Resources
+    def initialize
+      @fonts = {}
+      @images = {}
+      @states = {}
+    end
+
+    def font(font)
+      @fonts[font] ||= :"F#{@fonts.size + 1}"
+    end
+
+    def image(image)
+      @images[image] ||= :"Im#{@images.size + 1}"
+    end
+
+    def opacity(value)
+      @states[value.to_f.round(3)] ||= :"GS#{@states.size + 1}"
+    end
+
+    # Writes every resource once; returns { category => { name => ref } }.
+    def build(writer)
+      {
+        Font: @fonts.to_h { |font, name| [name, font.build(writer)] },
+        XObject: @images.to_h { |image, name| [name, image.build(writer)] },
+        ExtGState: @states.to_h { |alpha, name| [name, writer.add({ Type: :ExtGState, ca: alpha, CA: alpha })] }
+      }
+    end
+  end
+end

data/lib/stationery/text/entities.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    # Decodes the HTML entities markup text may carry.
+    module Entities
+      NAMED = { "amp" => "&", "lt" => "<", "gt" => ">", "quot" => "\"", "apos" => "'", "nbsp" => " " }.freeze
+      PATTERN = /&(#x\h+|#\d+|[a-zA-Z]+);/
+
+      module_function
+
+      def decode(text)
+        text.gsub(PATTERN) do |entity|
+          name = Regexp.last_match(1)
+          if name.start_with?("#x") then [name[2..].to_i(16)].pack("U")
+          elsif name.start_with?("#") then [name[1..].to_i].pack("U")
+          else NAMED.fetch(name, entity)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stationery/text/line.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    # A measured piece of one line in one style, positioned at `x` from the
+    # line's start.
+    Fragment = Data.define(:text, :style, :font, :face, :width, :x)
+
+    # One laid-out line. Vertical metrics come from its tallest fragment (or
+    # from the paragraph's base style when the line is empty).
+    class Line
+      attr_reader :fragments, :width, :ascent, :descent, :height
+
+      def initialize(fragments, fallback)
+        @fragments = fragments
+        @width = fragments.sum(&:width)
+        metrics = fragments.empty? ? [fallback] : fragments.map { |f| [f.font, f.style.render_size] }
+        @ascent = metrics.map { |font, size| font.ascender(size) }.max
+        @descent = metrics.map { |font, size| font.descender(size) }.max
+        @height = metrics.map { |font, size| font.line_height(size) }.max
+      end
+
+      def text = fragments.map(&:text).join
+    end
+  end
+end