stationery 0.1.0 → 0.3.0

data/lib/stationery/svg/style.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # Presentation attributes an element inherits from its ancestors, and the
+    # transform it draws with. An element's own values cascade: presentation
+    # attributes, then stylesheet rules, then its inline `style`.
+    class Style
+      INHERITED = %w[fill stroke stroke-width stroke-linecap stroke-linejoin fill-rule opacity fill-opacity
+                     stroke-opacity font-family font-size font-weight font-style text-anchor visibility].freeze
+      NAMED = { "black" => "#000000", "white" => "#FFFFFF", "red" => "#FF0000", "green" => "#008000",
+                "blue" => "#0000FF", "gray" => "#808080", "grey" => "#808080" }.freeze
+      DEFAULTS = { "fill" => "black", "stroke" => "none", "stroke-width" => "1" }.freeze
+      URL = /\Aurl\(\s*['"]?#([^'")\s]+)['"]?\s*\)\s*(.*)\z/
+
+      # A paint server reference, `url(#id)`, with its fallback colour (or nil).
+      Reference = Data.define(:id, :fallback)
+
+      def self.color(value, current)
+        value = value.to_s.strip
+        return current if value == "currentColor"
+
+        NAMED.fetch(value.downcase, value)
+      end
+
+      def self.declarations(style)
+        style.to_s.split(";").filter_map do |declaration|
+          key, value = declaration.split(":", 2).map(&:strip)
+          [key, value] if key && value
+        end.to_h
+      end
+
+      attr_reader :values, :matrix, :color
+
+      def initialize(values = DEFAULTS, matrix = [1, 0, 0, 1, 0, 0], color: "#000000", sheet: Stylesheet::EMPTY,
+                     display: nil)
+        @values = values
+        @matrix = matrix
+        @color = color
+        @sheet = sheet
+        @display = display
+      end
+
+      def child(element)
+        attributes = element.attributes
+        own = attributes.merge(@sheet.declarations(element), Style.declarations(attributes["style"]))
+        values = @values.merge(own.slice(*INHERITED))
+        matrix = if attributes["transform"]
+                   Transform.multiply(@matrix,
+                                      Transform.parse(attributes["transform"]))
+                 else
+                   @matrix
+                 end
+        Style.new(values, matrix, color: @color, sheet: @sheet, display: own["display"])
+      end
+
+      def displayed? = @display != "none"
+      def visible? = !%w[hidden collapse].include?(@values["visibility"])
+
+      def fill = paint("fill")
+      def stroke = paint("stroke")
+      def even_odd? = @values["fill-rule"] == "evenodd"
+      def cap = @values["stroke-linecap"]&.to_sym
+      def join = @values["stroke-linejoin"]&.to_sym
+
+      # Stroke width scales with the drawing, by the transform's area factor.
+      def line_width = @values["stroke-width"].to_f * Transform.scale(@matrix)
+
+      def opacity
+        %w[opacity fill-opacity stroke-opacity].filter_map { |key| @values[key]&.to_f }.reduce(1.0, :*)
+      end
+
+      private
+
+      def paint(key)
+        value = @values[key].to_s.strip
+        return nil if value.empty? || %w[none transparent].include?(value)
+        return Style.color(value, @color) unless (url = value.match(URL))
+
+        fallback = url[2]
+        Reference.new(url[1], fallback.empty? || fallback == "none" ? nil : Style.color(fallback, @color))
+      end
+    end
+  end
+end

data/lib/stationery/svg/stylesheet.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # The rules of a document's <style> elements. An element's declarations
+    # are those of every matching rule, the more specific winning and the
+    # later winning among equals. At-rules are skipped and `!important` is
+    # read as a plain declaration; rules whose selectors use combinators are
+    # ignored and listed in #unsupported.
+    class Stylesheet
+      Rule = Data.define(:selector, :declarations, :index)
+
+      RULE = /([^{}]+)\{([^{}]*)\}/
+      COMMENT = %r{/\*.*?\*/}m
+
+      def self.parse(css)
+        rules = []
+        unsupported = []
+        css.gsub(COMMENT, "").scan(RULE).each do |selectors, body|
+          next if selectors.strip.start_with?("@")
+
+          declarations = Style.declarations(body).transform_values { |value| value.sub(/\s*!important\z/, "") }
+          selectors.split(",").map(&:strip).each do |text|
+            selector = Selector.parse(text)
+            selector ? rules << Rule.new(selector, declarations, rules.size) : unsupported << text
+          end
+        end
+        new(rules, unsupported)
+      end
+
+      attr_reader :unsupported
+
+      def initialize(rules, unsupported)
+        @rules = rules
+        @unsupported = unsupported
+      end
+
+      EMPTY = new([], []).freeze
+
+      def declarations(element)
+        @rules.select { |rule| rule.selector.match?(element) }
+              .sort_by { |rule| [rule.selector.specificity, rule.index] }
+              .reduce({}) { |merged, rule| merged.merge(rule.declarations) }
+      end
+    end
+  end
+end

data/lib/stationery/svg/text.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # Lays out a <text> element: its strings and tspans become pieces along
+    # the baseline, a new chunk starting wherever x or y is set, and each
+    # chunk is shifted by its text-anchor. Glyphs are drawn upright at the
+    # transformed origin, sized by the transform's uniform scale, so rotated,
+    # skewed or unevenly scaled text is approximated.
+    class Text
+      ANCHORS = { "middle" => 0.5, "end" => 1.0 }.freeze
+      DEFAULT_SIZE = 16
+
+      Piece = Data.define(:runs, :style, :x, :y, :chunk, :advance)
+
+      def initialize(canvas, painter, book, family)
+        @canvas = canvas
+        @painter = painter
+        @book = book
+        @family = family
+      end
+
+      def draw(element, style)
+        @pieces = []
+        @x = @y = @chunk = 0
+        @space = true
+        place(element, style)
+        trim
+        @pieces.group_by(&:chunk).each_value { |chunk| draw_chunk(chunk) }
+      end
+
+      private
+
+      def place(element, style)
+        move(element.attributes)
+        element.children.each do |child|
+          if child.is_a?(String) then add(child, style)
+          elsif child.name == "tspan" then place(child, style.child(child))
+          end
+        end
+      end
+
+      def move(attributes)
+        x, y, dx, dy = attributes.values_at("x", "y", "dx", "dy").map { |value| first(value) }
+        @chunk += 1 if x || y
+        @x = (x || @x) + (dx || 0)
+        @y = (y || @y) + (dy || 0)
+      end
+
+      def first(value) = value.to_s.split(/[\s,]+/).find { |part| !part.empty? }&.to_f
+
+      # Collapses the space between pieces and at the start of the text.
+      def add(string, style)
+        string = string.lstrip if @space
+        return if string.empty?
+
+        @space = string.end_with?(" ")
+        @pieces << piece(string, style, @x, @y)
+        @x += @pieces.last.advance
+      end
+
+      def piece(string, style, x, y, chunk = @chunk)
+        italic = style.values["font-style"].to_s.match?(/italic|oblique/)
+        text_style = Stationery::Text::Style.new(family: family(style), size: size(style), weight: weight(style),
+                                                 style: italic ? :italic : :normal)
+        runs = @book.fallback([Stationery::Text::Run.new(string, text_style)])
+        advance = runs.sum { |run| font(run).width_of(run.text, text_style.size) }
+        Piece.new(runs, style, x, y, chunk, advance)
+      end
+
+      def trim
+        last = @pieces.last or return
+        text = last.runs.map(&:text).join
+        return unless text.end_with?(" ")
+
+        @pieces[-1] = piece(text.rstrip, last.style, last.x, last.y, last.chunk)
+      end
+
+      def draw_chunk(pieces)
+        width = pieces.last.x + pieces.last.advance - pieces.first.x
+        shift = -width * ANCHORS.fetch(pieces.first.style.values["text-anchor"].to_s, 0)
+        pieces.each { |piece| draw_piece(piece, shift) }
+      end
+
+      def draw_piece(piece, shift)
+        color = @painter.color(piece.style.fill, piece.style)
+        return unless color
+
+        x = piece.x + shift
+        scale = Transform.scale(piece.style.matrix)
+        piece.runs.each do |run|
+          font, face = @book.resolve(run.style)
+          page_x, page_y = Transform.apply(piece.style.matrix, x, piece.y)
+          @canvas.text(run.text, x: page_x, y: page_y, font:, size: run.style.size * scale, color:,
+                                 opacity: Painter.translucent(piece.style.opacity),
+                                 synthetic_bold: face.synthetic_bold, synthetic_oblique: face.synthetic_oblique)
+          x += font.width_of(run.text, run.style.size)
+        end
+      end
+
+      def font(run) = @book.resolve(run.style).first
+
+      # The first family of the list the book knows, else the document's.
+      def family(style)
+        names = style.values["font-family"].to_s.split(",").map { |name| name.strip.delete("'\"") }
+        names.find { |name| !name.empty? && @book.known?(name) } || @family
+      end
+
+      def size(style)
+        size = style.values["font-size"].to_f
+        size.positive? ? size : DEFAULT_SIZE
+      end
+
+      def weight(style)
+        value = style.values["font-weight"].to_s.strip
+        return value.to_i if value.match?(/\A\d+\z/)
+
+        %w[bold bolder].include?(value) ? :bold : :regular
+      end
+    end
+  end
+end

data/lib/stationery/svg/transform.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # SVG `transform` attributes as affine matrices [a, b, c, d, e, f].
+    module Transform
+      FUNCTION = /(matrix|translate|scale|rotate|skewX|skewY)\s*\(([^)]*)\)/
+
+      module_function
+
+      def parse(source)
+        source.scan(FUNCTION).reduce([1, 0, 0, 1, 0, 0]) do |matrix, (name, args)|
+          multiply(matrix, function(name, args.split(/[\s,]+/).reject(&:empty?).map(&:to_f)))
+        end
+      end
+
+      def function(name, args)
+        case name
+        when "matrix" then args
+        when "translate" then [1, 0, 0, 1, args[0], args[1] || 0]
+        when "scale" then [args[0], 0, 0, args[1] || args[0], 0, 0]
+        when "rotate" then rotate(*args)
+        when "skewX" then [1, 0, Math.tan(args[0] * Math::PI / 180), 1, 0, 0]
+        else [1, Math.tan(args[0] * Math::PI / 180), 0, 1, 0, 0]
+        end
+      end
+
+      def rotate(degrees, cx = 0, cy = 0)
+        r = degrees * Math::PI / 180
+        rotation = [Math.cos(r), Math.sin(r), -Math.sin(r), Math.cos(r), 0, 0]
+        multiply(multiply([1, 0, 0, 1, cx, cy], rotation), [1, 0, 0, 1, -cx, -cy])
+      end
+
+      def apply(matrix, x, y)
+        a, b, c, d, e, f = matrix
+        [(a * x) + (c * y) + e, (b * x) + (d * y) + f]
+      end
+
+      # The uniform scale a matrix applies to areas, as a length factor.
+      def scale(matrix)
+        a, b, c, d, = matrix
+        Math.sqrt(((a * d) - (b * c)).abs)
+      end
+
+      # The transform that applies `inner` first, then `outer`.
+      def multiply(outer, inner)
+        a, b, c, d, e, f = outer
+        ia, ib, ic, id, ie, if_ = inner
+        [(a * ia) + (c * ib), (b * ia) + (d * ib), (a * ic) + (c * id), (b * ic) + (d * id),
+         (a * ie) + (c * if_) + e, (b * ie) + (d * if_) + f]
+      end
+    end
+  end
+end

data/lib/stationery/testing/inspector.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "stringio"
+require "stationery"
+
+module Stationery
+  module Testing
+    # Reads a rendered PDF back for assertions. The subject is a
+    # Stationery::Document, PDF bytes, a path (String or Pathname) or an IO.
+    # Needs the pdf-reader gem, loaded on first use.
+    class Inspector
+      UTF16_BOM = "\xFE\xFF".b
+
+      def initialize(subject)
+        @subject = subject
+      end
+
+      def pdf
+        @pdf ||= case @subject
+                 when Document then @subject.to_pdf
+                 when String then @subject.start_with?("%PDF") ? @subject : File.binread(@subject)
+                 when Pathname then File.binread(@subject)
+                 else @subject.read
+                 end
+      end
+
+      def reader
+        @reader ||= begin
+          require "pdf/reader"
+          ::PDF::Reader.new(StringIO.new(pdf))
+        rescue LoadError
+          raise Stationery::Error, 'Stationery::Testing needs pdf-reader: add gem "pdf-reader" to your test group'
+        end
+      end
+
+      def page_count = reader.page_count
+      def page_texts = @page_texts ||= reader.pages.map { |page| page.text.squeeze(" ").strip }
+      def text = page_texts.join("\n")
+      def metadata = reader.info
+      def image_count = pdf.scan(%r{/Subtype\s*/Image\b}).size
+
+      def warnings
+        return [] unless @subject.is_a?(Document)
+
+        pdf
+        @subject.warnings.to_a
+      end
+
+      def links
+        annotations.filter_map { |annot| annot.dig(:A, :URI) if annot.dig(:A, :S) == :URI }
+      end
+
+      def internal_links
+        annotations.filter_map do |annot|
+          dest = annot[:Dest] || (annot.dig(:A, :D) if annot.dig(:A, :S) == :GoTo)
+          destination(dest) if dest
+        end
+      end
+
+      def bookmarks
+        outlines = objects.deref!(objects.trailer[:Root])[:Outlines]
+        outlines ? titles(outlines[:First]) : []
+      end
+
+      private
+
+      def objects = reader.objects
+
+      def annotations
+        reader.pages.flat_map do |page|
+          Array(objects.deref_array(page.attributes[:Annots])).map do |ref|
+            annot = objects.deref_hash(ref)
+            annot.merge(A: objects.deref_hash(annot[:A]))
+          end
+        end
+      end
+
+      def destination(dest)
+        return dest.to_s unless dest.is_a?(Array)
+
+        objects.page_references.index(dest.first) + 1
+      end
+
+      def titles(item)
+        return [] unless item
+
+        [decode(item[:Title]), *titles(item[:First]), *titles(item[:Next])]
+      end
+
+      def decode(title)
+        return title.dup.force_encoding(Encoding::UTF_8) unless title.b.start_with?(UTF16_BOM)
+
+        title.b.byteslice(2..).force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8)
+      end
+    end
+  end
+end

data/lib/stationery/testing/matchers.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "inspector"
+
+module Stationery
+  module Testing
+    # Framework-independent PDF matchers: each answers matches?(subject),
+    # failure_message, failure_message_when_negated and description, so RSpec
+    # uses them directly and Minitest assertions wrap them.
+    module Matchers
+      EXCERPT = 500
+
+      class Base
+        def initialize(expected = nil)
+          @expected = expected
+        end
+
+        def matches?(subject)
+          @inspector = subject.is_a?(Inspector) ? subject : Inspector.new(subject)
+          match?(@inspector)
+        end
+
+        def failure_message = "expected PDF to #{description}, #{actual}"
+        def failure_message_when_negated = "expected PDF not to #{description}, #{actual}"
+
+        private
+
+        def show(expected) = expected.is_a?(Regexp) ? expected.inspect : expected.to_s.inspect
+
+        def contains?(haystack, expected)
+          expected.is_a?(Regexp) ? expected.match?(haystack) : haystack.include?(expected.to_s)
+        end
+
+        def excerpt(text)
+          text.length > EXCERPT ? "#{text[0, EXCERPT]}…" : text
+        end
+      end
+
+      class HaveText < Base
+        def description = "have text #{show(@expected)}"
+
+        private
+
+        def match?(pdf) = contains?(pdf.text, @expected)
+        def actual = "got text:\n#{excerpt(@inspector.text)}"
+      end
+
+      class HaveTextOnPage < Base
+        def initialize(page, expected)
+          super(expected)
+          @page = page
+        end
+
+        def description = "have text #{show(@expected)} on page #{@page}"
+
+        private
+
+        def page_text = @inspector.page_texts.fetch(@page - 1, nil)
+        def match?(_pdf) = !page_text.nil? && contains?(page_text, @expected)
+
+        def actual
+          return "but it has #{@inspector.page_count} page(s)" if page_text.nil?
+
+          "got text on page #{@page}:\n#{excerpt(page_text)}"
+        end
+      end
+
+      class HavePageCount < Base
+        def description = "have #{@expected} page(s)"
+
+        private
+
+        def match?(pdf) = pdf.page_count == @expected
+        def actual = "got #{@inspector.page_count}"
+      end
+
+      class HaveLink < Base
+        def description = "have a link to #{show(@expected)}"
+
+        private
+
+        def match?(pdf) = pdf.links.any? { |url| @expected.is_a?(Regexp) ? @expected.match?(url) : url == @expected }
+        def actual = "got links #{@inspector.links.inspect}"
+      end
+
+      class HaveImageCount < Base
+        def description = "have #{@expected} image(s)"
+
+        private
+
+        def match?(pdf) = pdf.image_count == @expected
+        def actual = "got #{@inspector.image_count}"
+      end
+
+      class HaveBookmark < Base
+        def description = "have a bookmark #{show(@expected)}"
+
+        private
+
+        def match?(pdf) = pdf.bookmarks.include?(@expected)
+        def actual = "got bookmarks #{@inspector.bookmarks.inspect}"
+      end
+
+      class HaveNoWarnings < Base
+        def description = "have no warnings"
+
+        private
+
+        def match?(pdf) = pdf.warnings.empty?
+        def messages = @inspector.warnings.map(&:message)
+        def actual = messages.empty? ? "got none" : "got:\n#{messages.map { |m| "  - #{m}" }.join("\n")}"
+      end
+
+      def have_pdf_text(expected) = HaveText.new(expected)
+      def have_pdf_text_on_page(page, expected) = HaveTextOnPage.new(page, expected)
+      def have_page_count(expected) = HavePageCount.new(expected)
+      def have_pdf_link(expected) = HaveLink.new(expected)
+      def have_image_count(expected) = HaveImageCount.new(expected)
+      def have_bookmark(title) = HaveBookmark.new(title)
+      def have_no_warnings = HaveNoWarnings.new
+    end
+  end
+end

data/lib/stationery/text/entities/html4.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    module Entities
+      # The 252 named character references of HTML 4.
+      HTML4 = { # rubocop:disable Metrics/CollectionLiteralLength
+        "AElig" => "Æ", "Aacute" => "Á", "Acirc" => "Â", "Agrave" => "À", "Alpha" => "Α", "Aring" => "Å",
+        "Atilde" => "Ã", "Auml" => "Ä", "Beta" => "Β", "Ccedil" => "Ç", "Chi" => "Χ", "Dagger" => "‡", "Delta" => "Δ",
+        "ETH" => "Ð", "Eacute" => "É", "Ecirc" => "Ê", "Egrave" => "È", "Epsilon" => "Ε", "Eta" => "Η", "Euml" => "Ë",
+        "Gamma" => "Γ", "Iacute" => "Í", "Icirc" => "Î", "Igrave" => "Ì", "Iota" => "Ι", "Iuml" => "Ï", "Kappa" => "Κ",
+        "Lambda" => "Λ", "Mu" => "Μ", "Ntilde" => "Ñ", "Nu" => "Ν", "OElig" => "Œ", "Oacute" => "Ó", "Ocirc" => "Ô",
+        "Ograve" => "Ò", "Omega" => "Ω", "Omicron" => "Ο", "Oslash" => "Ø", "Otilde" => "Õ", "Ouml" => "Ö",
+        "Phi" => "Φ", "Pi" => "Π", "Prime" => "″", "Psi" => "Ψ", "Rho" => "Ρ", "Scaron" => "Š", "Sigma" => "Σ",
+        "THORN" => "Þ", "Tau" => "Τ", "Theta" => "Θ", "Uacute" => "Ú", "Ucirc" => "Û", "Ugrave" => "Ù",
+        "Upsilon" => "Υ", "Uuml" => "Ü", "Xi" => "Ξ", "Yacute" => "Ý", "Yuml" => "Ÿ", "Zeta" => "Ζ", "aacute" => "á",
+        "acirc" => "â", "acute" => "´", "aelig" => "æ", "agrave" => "à", "alefsym" => "ℵ", "alpha" => "α", "amp" => "&",
+        "and" => "∧", "ang" => "∠", "aring" => "å", "asymp" => "≈", "atilde" => "ã", "auml" => "ä", "bdquo" => "„",
+        "beta" => "β", "brvbar" => "¦", "bull" => "•", "cap" => "∩", "ccedil" => "ç", "cedil" => "¸", "cent" => "¢",
+        "chi" => "χ", "circ" => "ˆ", "clubs" => "♣", "cong" => "≅", "copy" => "©", "crarr" => "↵", "cup" => "∪",
+        "curren" => "¤", "dArr" => "⇓", "dagger" => "†", "darr" => "↓", "deg" => "°", "delta" => "δ", "diams" => "♦",
+        "divide" => "÷", "eacute" => "é", "ecirc" => "ê", "egrave" => "è", "empty" => "∅", "emsp" => "\u2003",
+        "ensp" => "\u2002", "epsilon" => "ε", "equiv" => "≡", "eta" => "η", "eth" => "ð", "euml" => "ë", "euro" => "€",
+        "exist" => "∃", "fnof" => "ƒ", "forall" => "∀", "frac12" => "½", "frac14" => "¼", "frac34" => "¾",
+        "frasl" => "⁄", "gamma" => "γ", "ge" => "≥", "gt" => ">", "hArr" => "⇔", "harr" => "↔", "hearts" => "♥",
+        "hellip" => "…", "iacute" => "í", "icirc" => "î", "iexcl" => "¡", "igrave" => "ì", "image" => "ℑ",
+        "infin" => "∞", "int" => "∫", "iota" => "ι", "iquest" => "¿", "isin" => "∈", "iuml" => "ï", "kappa" => "κ",
+        "lArr" => "⇐", "lambda" => "λ", "lang" => "〈", "laquo" => "«", "larr" => "←", "lceil" => "⌈", "ldquo" => "“",
+        "le" => "≤", "lfloor" => "⌊", "lowast" => "∗", "loz" => "◊", "lrm" => "\u200E", "lsaquo" => "‹", "lsquo" => "‘",
+        "lt" => "<", "macr" => "¯", "mdash" => "—", "micro" => "µ", "middot" => "·", "minus" => "−", "mu" => "μ",
+        "nabla" => "∇", "nbsp" => "\u00A0", "ndash" => "–", "ne" => "≠", "ni" => "∋", "not" => "¬", "notin" => "∉",
+        "nsub" => "⊄", "ntilde" => "ñ", "nu" => "ν", "oacute" => "ó", "ocirc" => "ô", "oelig" => "œ", "ograve" => "ò",
+        "oline" => "‾", "omega" => "ω", "omicron" => "ο", "oplus" => "⊕", "or" => "∨", "ordf" => "ª", "ordm" => "º",
+        "oslash" => "ø", "otilde" => "õ", "otimes" => "⊗", "ouml" => "ö", "para" => "¶", "part" => "∂", "permil" => "‰",
+        "perp" => "⊥", "phi" => "φ", "pi" => "π", "piv" => "ϖ", "plusmn" => "±", "pound" => "£", "prime" => "′",
+        "prod" => "∏", "prop" => "∝", "psi" => "ψ", "quot" => "\"", "rArr" => "⇒", "radic" => "√", "rang" => "〉",
+        "raquo" => "»", "rarr" => "→", "rceil" => "⌉", "rdquo" => "”", "real" => "ℜ", "reg" => "®", "rfloor" => "⌋",
+        "rho" => "ρ", "rlm" => "\u200F", "rsaquo" => "›", "rsquo" => "’", "sbquo" => "‚", "scaron" => "š",
+        "sdot" => "⋅", "sect" => "§", "shy" => "\u00AD", "sigma" => "σ", "sigmaf" => "ς", "sim" => "∼", "spades" => "♠",
+        "sub" => "⊂", "sube" => "⊆", "sum" => "∑", "sup" => "⊃", "sup1" => "¹", "sup2" => "²", "sup3" => "³",
+        "supe" => "⊇", "szlig" => "ß", "tau" => "τ", "there4" => "∴", "theta" => "θ", "thetasym" => "ϑ",
+        "thinsp" => "\u2009", "thorn" => "þ", "tilde" => "˜", "times" => "×", "trade" => "™", "uArr" => "⇑",
+        "uacute" => "ú", "uarr" => "↑", "ucirc" => "û", "ugrave" => "ù", "uml" => "¨", "upsih" => "ϒ", "upsilon" => "υ",
+        "uuml" => "ü", "weierp" => "℘", "xi" => "ξ", "yacute" => "ý", "yen" => "¥", "yuml" => "ÿ", "zeta" => "ζ",
+        "zwj" => "\u200D", "zwnj" => "\u200C"
+      }.freeze
+    end
+  end
+end

data/lib/stationery/text/entities.rb

@@ -14,10 +14,15 @@ module Stationery
           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)
+          else NAMED.fetch(name) { html4.fetch(name, entity) }
           end
         end
       end
+
+      def html4
+        require_relative "entities/html4" unless defined?(HTML4)
+        HTML4
+      end
     end
   end
 end

data/lib/stationery/text/line.rb

@@ -7,12 +7,14 @@ module Stationery
     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).
+    # from the paragraph's base style when the line is empty). A soft-wrapped
+    # line is justifiable; the last line and one ended by a newline are not.
     class Line
       attr_reader :fragments, :width, :ascent, :descent, :height
 
-      def initialize(fragments, fallback)
+      def initialize(fragments, fallback, justifiable: false)
         @fragments = fragments
+        @justifiable = justifiable
         @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
@@ -21,6 +23,10 @@ module Stationery
       end
 
       def text = fragments.map(&:text).join
+      def justifiable? = @justifiable
+
+      # U+0020 spaces only: justification stretches those, never tabs.
+      def space_count = fragments.sum { |fragment| fragment.text.count(" ") }
     end
   end
 end