stationery 0.4.0 → 0.6.0

data/lib/stationery/instrumentation.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Stationery
+  # Events a render emits, named `<phase>.stationery` so tools that group by
+  # the last segment (AppSignal, Skylight, Rails log subscribers) file them
+  # together. With ActiveSupport::Notifications loaded they go there and
+  # subscribers see the same payload the block filled in; otherwise a Null
+  # instrumenter yields and costs one method call.
+  module Instrumentation
+    class Null
+      def instrument(_name, payload = {})
+        yield payload
+      end
+    end
+
+    class << self
+      # Any object answering `instrument(name, payload) { |payload| }`; set
+      # once at boot, so a plain module attribute is enough.
+      attr_writer :instrumenter # rubocop:disable ThreadSafety/ClassAndModuleAttributes
+
+      def instrumenter
+        @instrumenter ||= defined?(::ActiveSupport::Notifications) ? ::ActiveSupport::Notifications : Null.new # rubocop:disable ThreadSafety/ClassInstanceVariable
+      end
+
+      def instrument(name, payload = {}, &)
+        instrumenter.instrument(name, payload, &)
+      end
+    end
+  end
+
+  class << self
+    def instrumenter = Instrumentation.instrumenter
+
+    def instrumenter=(value)
+      Instrumentation.instrumenter = value
+    end
+
+    # Runs the block as one `name` event; the block may add to `payload`.
+    def instrument(name, payload = {}, &) = Instrumentation.instrument(name, payload, &)
+  end
+end

data/lib/stationery/layout/box.rb

@@ -10,15 +10,20 @@ module Stationery
     # fixed-height box can truncate or shrink text that does not fit
     # (`overflow:`) and never splits. `min_height:` is a floor that does split:
     # the first fragment keeps as much of it as the page holds and the next
-    # one carries only what is left of it.
+    # one carries only what is left of it. `rotate:` turns the painted box
+    # around its centre without moving its layout rectangle (a rotated box
+    # never splits); `shadow:` paints a soft drop shadow under it, taking no
+    # space; `overflow: :hidden` clips the content to the rounded outline.
     class Box < Node
       BORDER = { width: 1, color: "#000000", sides: %i[top right bottom left] }.freeze
+      SHADOW = { offset: [0, 4], blur: 8, color: "#000000", opacity: 0.15 }.freeze
+      SHADOW_LAYERS = 8
 
       attr_reader :content, :width_spec
 
       def initialize(content = Flow.new, padding: 0, background: nil, border: nil, radius: 0, width: nil,
                      height: nil, min_height: nil, overflow: :visible, valign: :top, opacity: nil, link: nil, outset: 0,
-                     open: [], decoration: :slice, role: nil)
+                     open: [], decoration: :slice, role: nil, rotate: 0, shadow: nil)
         raise ArgumentError, "pass height: or min_height:, not both" if height && min_height
 
         super()
@@ -39,6 +44,8 @@ module Stationery
         @overflow = overflow
         @valign = valign
         @opacity = opacity
+        @rotate = rotate
+        @shadow = shadow && SHADOW.merge(shadow == true ? {} : shadow)
       end
 
       def natural_width
@@ -55,7 +62,10 @@ module Stationery
         end
       end
 
-      def splittable? = @height.nil? && @overflow == :visible && @content.splittable?
+      def splittable?
+        @height.nil? && @rotate.zero? && %i[visible hidden].include?(@overflow) && @content.splittable?
+      end
+
       def prefer_whole? = break_inside.nil? && splittable?
 
       def split(width, height, fresh: false)
@@ -83,15 +93,18 @@ module Stationery
 
       def paint(canvas, x, y, width, height = nil, valign: nil, debug_kind: :box, **)
         height ||= measure(width)
-        canvas.structure(@tag) do
-          canvas.structure(@link_tag) do
-            paint_background(canvas, x, y, width, height)
-            paint_border(canvas, x, y, width, height)
-            paint_content(canvas, x, y, width, height, valign || @valign)
+        canvas.rotate(@rotate, around: [x + (width / 2.0), y + (height / 2.0)]) do
+          canvas.structure(@tag) do
+            canvas.structure(@link_tag) do
+              paint_shadow(canvas, x, y, width, height)
+              paint_background(canvas, x, y, width, height)
+              paint_border(canvas, x, y, width, height)
+              paint_content(canvas, x, y, width, height, valign || @valign)
+            end
           end
+          paint_debug(canvas, Rect.new(x, y, width, height), debug_kind) if canvas.debug?
         end
         canvas.link(x, y, width, height, @link, tag: @link_tag) if @link
-        paint_debug(canvas, Rect.new(x, y, width, height), debug_kind) if canvas.debug?
       end
 
       protected
@@ -125,6 +138,27 @@ module Stationery
       def vertical(open = @open) = insets(open).values_at(0, 2).sum
       def inner_width(width) = [width - horizontal, 0].max
 
+      # Stacked rounded rectangles under the box, the outermost grown by the
+      # blur and each fainter, so the centre sums to the opacity and the edge
+      # fades. An artifact: decoration, not content. Skipped on a fragment
+      # with cut sides, whose corners are square anyway.
+      def paint_shadow(canvas, x, y, width, height)
+        return unless @shadow && @open.empty?
+
+        blur = @shadow[:blur].to_f
+        layers = blur.positive? ? [(blur / 2).ceil, SHADOW_LAYERS].min : 1
+        dx, dy = @shadow[:offset]
+        canvas.artifact do
+          layers.downto(1) do |layer|
+            grow = blur * layer / layers
+            canvas.rounded_rect(x + dx - grow, y + dy - grow, width + (2 * grow), height + (2 * grow),
+                                radius: grown_radius(grow), fill: @shadow[:color], opacity: @shadow[:opacity] / layers)
+          end
+        end
+      end
+
+      def grown_radius(grow) = @radius.is_a?(Array) ? @radius.map { |r| r + grow } : @radius + grow
+
       # The outset paints the background past the box's own edges (a band that
       # bleeds into the page margins) without moving the content.
       def paint_background(canvas, x, y, width, height)
@@ -190,15 +224,27 @@ module Stationery
                                        end,
                                        inner.height, used)
         paint_inner = -> { content.paint(canvas, x + left, y + top + [offset, 0].max, inner.width) }
-        if @overflow == :visible
-          paint_inner.call
-        else
-          canvas.clip(inner.x, inner.y, inner.width, inner.height) do
+        clip_outline(canvas, Rect.new(x, y, width, height)) do
+          if @overflow == :visible || (@overflow == :hidden && @height.nil?)
             paint_inner.call
+          else
+            canvas.clip(inner.x, inner.y, inner.width, inner.height) do
+              paint_inner.call
+            end
           end
         end
       end
 
+      # `overflow: :hidden` keeps the content inside the rounded outline; cut
+      # sides stay square like the background's.
+      def clip_outline(canvas, area, &)
+        return yield unless @overflow == :hidden && @radius.positive?
+
+        cut(canvas, area, area) do |shape|
+          canvas.clip(shape.x, shape.y, shape.width, shape.height, radius: @radius, &)
+        end
+      end
+
       def paint_debug(canvas, rect, kind)
         canvas.debug_rect(rect.x, rect.y, rect.width, rect.height, kind)
         return if insets.all?(&:zero?)

data/lib/stationery/layout/image.rb

@@ -4,10 +4,16 @@ module Stationery
   module Layout
     # An image sized by width, height, both, or a box to fit into (aspect
     # preserved), never wider than the space it is given. One pixel is one
-    # point when no size is given.
+    # point when no size is given. `fit: :cover` fills `width:` × `height:`
+    # instead, scaling up and clipping the excess around the centre.
+    # `radius:` clips to rounded corners and `rotate:` (degrees, clockwise)
+    # turns the painted image around the centre of its rectangle; neither
+    # changes the space the image takes up.
     class Image < Node
       # `alt:` describes the image in a tagged PDF; `alt: false` marks it decorative.
-      def initialize(source, width: nil, height: nil, fit: nil, opacity: nil, alt: nil)
+      def initialize(source, width: nil, height: nil, fit: nil, opacity: nil, alt: nil, radius: 0, rotate: 0)
+        raise ArgumentError, "fit: :cover needs width: and height:" if fit == :cover && !(width && height)
+
         super()
         @tag = alt == false ? nil : Tagging::Element.new(:Figure, alt:, kind: :image)
         @image = source.respond_to?(:build) ? source : Images.load(source)
@@ -15,6 +21,8 @@ module Stationery
         @height = height
         @fit = fit
         @opacity = opacity
+        @radius = radius
+        @rotate = rotate
       end
 
       def size(available)
@@ -31,16 +39,37 @@ module Stationery
 
       def paint(canvas, x, y, width, _height = nil, **)
         w, h = size(width)
-        canvas.tag(@tag, bbox: [x, y, w, h]) { canvas.image(@image, x:, y:, width: w, height: h, opacity: @opacity) }
+        canvas.tag(@tag, bbox: [x, y, w, h]) do
+          canvas.rotate(@rotate, around: [x + (w / 2.0), y + (h / 2.0)]) { paint_clipped(canvas, x, y, w, h) }
+        end
         canvas.debug_rect(x, y, w, h, :image)
       end
 
       private
 
+      def paint_clipped(canvas, x, y, w, h)
+        return paint_image(canvas, x, y, w, h) unless @fit == :cover || @radius.positive?
+
+        canvas.clip(x, y, w, h, radius: @radius) { paint_image(canvas, x, y, w, h) }
+      end
+
+      def paint_image(canvas, x, y, w, h)
+        if @fit == :cover
+          scale = [w / @image.width.to_f, h / @image.height.to_f].max
+          cw = tidy(@image.width * scale)
+          ch = tidy(@image.height * scale)
+          x = tidy(x - ((cw - w) / 2.0))
+          y = tidy(y - ((ch - h) / 2.0))
+          w = cw
+          h = ch
+        end
+        canvas.image(@image, x:, y:, width: w, height: h, opacity: @opacity)
+      end
+
       def requested
         iw = @image.width.to_f
         ih = @image.height.to_f
-        if @fit
+        if @fit.is_a?(Array)
           scale = [@fit[0] / iw, @fit[1] / ih].min
           [iw * scale, ih * scale].map { |v| tidy(v) }
         elsif @width && @height then [@width, @height]

data/lib/stationery/layout/stack.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Layout
+    # A base flow with layers painted over it. The base sets the height and
+    # widths; each Layer is placed relative to the stack's rectangle and takes
+    # no space, so it can overhang the edges. A stack never splits: it moves
+    # to the next page whole (and is reported as an Overflow when taller than
+    # a page).
+    class Stack < Node
+      attr_reader :base, :layers
+
+      def initialize(base, layers)
+        super()
+        @base = base
+        @layers = layers
+      end
+
+      def measure(width) = @base.measure(width)
+      def natural_width = @base.natural_width
+      def min_width = @base.min_width
+      def fixed_width(available) = @base.fixed_width(available)
+      def prefer_whole? = true
+
+      def paint(canvas, x, y, width, height = nil, **)
+        height ||= measure(width)
+        @base.paint(canvas, x, y, width, height)
+        @layers.each { |layer| layer.paint(canvas, x, y, width, height) }
+        canvas.debug_rect(x, y, width, height, :stack)
+      end
+    end
+
+    # A box placed over a Stack by CSS-like insets. `top:`, `right:`,
+    # `bottom:`, `left:`, `width:` and `height:` are points, or fractions of
+    # the stack's width (horizontal ones) or height (vertical ones) when given
+    # as a Rational or a Float between -1 and 1; negative points overhang.
+    # Without `left:`/`top:` the layer sits at the stack's left/top edge;
+    # without `width:` it takes its content's natural width, at most the
+    # stack's, and without `height:` its content's height.
+    class Layer
+      def initialize(box, top: nil, right: nil, bottom: nil, left: nil, width: nil, height: nil)
+        @box = box
+        @top = top
+        @right = right
+        @bottom = bottom
+        @left = left
+        @width = width
+        @height = height
+      end
+
+      def paint(canvas, x, y, width, height)
+        own = layer_width(width)
+        tall = @height ? resolve(@height, height) : @box.measure(own)
+        @box.paint(canvas, x + offset(@left, @right, width, own), y + offset(@top, @bottom, height, tall), own, tall)
+      end
+
+      private
+
+      # Where the layer's near edge sits along one axis of the stack: `start`
+      # points from the start edge, else `finish` points before the end edge.
+      def offset(start, finish, extent, own)
+        return resolve(start, extent) if start
+        return extent - resolve(finish, extent) - own if finish
+
+        0
+      end
+
+      def layer_width(width)
+        return [@box.natural_width, width].min unless @width
+
+        resolve(@width, width)
+      end
+
+      def resolve(value, extent)
+        fraction?(value) ? extent * value : value
+      end
+
+      def fraction?(value) = value.is_a?(Rational) || (value.is_a?(Float) && value.abs <= 1)
+    end
+  end
+end

data/lib/stationery/markdown/document.rb

@@ -7,8 +7,10 @@ module Stationery
   # A CommonMark subset (plus GFM tables and strikethrough) to rich-text blocks (see Stationery::Rich).
   module Markdown
     def self.parse(source)
-      refs = {}
-      Resolver.new(refs).blocks(BlockParser.parse(source, refs))
+      Stationery.instrument("parse.stationery", format: :markdown, bytes: source.bytesize) do
+        refs = {}
+        Resolver.new(refs).blocks(BlockParser.parse(source, refs))
+      end
     end
 
     # Runs the raw text the block parser left in paragraphs, headings and cells through the inline parser.

data/lib/stationery/minitest.rb

@@ -16,6 +16,7 @@ module Stationery
       def assert_pdf_link(subject, url, msg = nil) = assert_pdf(Matchers::HaveLink.new(url), subject, msg)
       def assert_image_count(subject, count, msg = nil) = assert_pdf(Matchers::HaveImageCount.new(count), subject, msg)
       def assert_bookmark(subject, title, msg = nil) = assert_pdf(Matchers::HaveBookmark.new(title), subject, msg)
+      def assert_pdf_language(subject, lang, msg = nil) = assert_pdf(Matchers::HaveLanguage.new(lang), subject, msg)
       def assert_no_pdf_warnings(subject, msg = nil) = assert_pdf(Matchers::HaveNoWarnings.new, subject, msg)
       def assert_pdf_structure(subject, tree, msg = nil) = assert_pdf(Matchers::HaveStructure.new(tree), subject, msg)
       def assert_tagged_content(subject, msg = nil) = assert_pdf(Matchers::HaveTaggedContent.new, subject, msg)

data/lib/stationery/preview.rb

@@ -4,15 +4,19 @@ require "stationery"
 
 module Stationery
   # Browsable sample documents, like ActionMailer previews. Each public method
-  # returns one document:
+  # returns one document. `around_render` wraps building and rendering it,
+  # for anything that must be in effect while the document paints:
   #
   #   # spec/pdfs/previews/invoice_pdf_preview.rb
   #   class InvoicePdfPreview < Stationery::Preview
   #     def paid = InvoicePdf.new(Invoice.first)
   #     def overdue(params) = InvoicePdf.new(Invoice.find(params.fetch("id")))
+  #
+  #     def around_render(_name, params) = I18n.with_locale(params.fetch("locale", I18n.default_locale)) { yield }
   #   end
   class Preview
     REGISTRY_LOCK = Mutex.new
+    HOOKS = %w[around_render].freeze
 
     class << self
       def inherited(subclass)
@@ -40,7 +44,7 @@ module Stationery
       end
 
       def preview_name = underscore(name.delete_suffix("Preview"))
-      def pdfs = public_instance_methods(false).sort.map(&:to_s)
+      def pdfs = public_instance_methods(false).sort.map(&:to_s) - HOOKS
 
       protected
 
@@ -53,6 +57,19 @@ module Stationery
       end
     end
 
+    # The PDF bytes of one preview, built and rendered inside around_render.
+    # `debug: true` reaches to_pdf when the document accepts it.
+    def to_pdf(name, params = {}, debug: false)
+      around_render(name, params) do
+        document = render(name, params)
+        document.to_pdf(**(debug && accepts_debug?(document) ? { debug: true } : {}))
+      end
+    end
+
+    # Override to wrap the preview: set an I18n locale, Current attributes,
+    # a time zone. Both the preview method and to_pdf run inside the block.
+    def around_render(_name, _params) = yield
+
     def render(name, params = {})
       method = public_method(name)
       document = method.arity.zero? ? method.call : method.call(params)
@@ -60,5 +77,9 @@ module Stationery
 
       raise Error, "#{self.class}##{name} must return a Stationery::Document (got #{document.class})"
     end
+
+    private
+
+    def accepts_debug?(document) = document.method(:to_pdf).parameters.include?(%i[key debug])
   end
 end

data/lib/stationery/rails/previews_controller.rb

@@ -19,8 +19,8 @@ module Stationery
       klass, pdf = Preview.find(params[:path])
       return head(:not_found) unless klass
 
-      document = klass.new.render(pdf, request.query_parameters.except("debug"))
-      send_data document.to_pdf(**debug_option(document)), type: "application/pdf", disposition: "inline"
+      pdf = klass.new.to_pdf(pdf, request.query_parameters.except("debug"), debug: params[:debug].present?)
+      send_data pdf, type: "application/pdf", disposition: "inline"
     end
 
     private
@@ -35,11 +35,6 @@ module Stationery
       Preview.load(Railtie.preview_paths(::Rails.root, config.preview_paths))
     end
 
-    def debug_option(document)
-      debug = params[:debug].present? && document.method(:to_pdf).parameters.include?(%i[key debug])
-      debug ? { debug: true } : {}
-    end
-
     def page(paths)
       items = paths.map do |path|
         href = ERB::Util.html_escape("#{request.path.chomp("/")}/#{path}")

data/lib/stationery/railtie.rb

@@ -23,6 +23,11 @@ module Stationery
       Railtie.add_renderer if app.config.stationery.renderer
     end
 
+    # Whatever the require order, a Rails app reports through ActiveSupport::Notifications.
+    initializer "stationery.instrumentation" do
+      Stationery.instrumenter = ActiveSupport::Notifications
+    end
+
     initializer "stationery.previews" do |app|
       Railtie.add_previews(app.routes) if app.config.stationery.show_previews
     end

data/lib/stationery/rich/renderer/inlines.rb

@@ -19,16 +19,24 @@ module Stationery
           bold: [[:b]], italic: [[:i]], underline: [[:u]], strike: [[:strikethrough]]
         }.freeze
 
-        def initialize(runs, styles)
+        def initialize(runs, styles, links = Links.new(:all, nil))
           @runs = runs
           @styles = styles
+          @links = links
         end
 
         def write(inlines) = inlines.grep(Inline).each { |inline| inline.break? ? @runs.br : write_one(inline) }
 
         private
 
-        def write_one(inline) = nest(inline.marks.flat_map { |mark, value| steps(mark, value) }, inline.text)
+        def write_one(inline) = nest(marks_of(inline).flat_map { |mark, value| steps(mark, value) }, inline.text)
+
+        def marks_of(inline)
+          marks = inline.marks
+          return marks unless marks.key?(:link) && !@links.allowed?(marks[:link])
+
+          marks.except(:link)
+        end
 
         def nest(steps, text)
           return @runs.plain(text) if steps.empty?

data/lib/stationery/rich/renderer/links.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Rich
+    class Renderer
+      # Which hrefs become link annotations: `#anchor` always, otherwise only
+      # the allowed URL schemes (case-insensitive). A dropped href keeps its
+      # text and is reported once as a DroppedLink warning. `:all` keeps every
+      # href, for trusted sources.
+      class Links
+        SCHEME = /\A([a-z][a-z0-9+.-]*):/i
+
+        def initialize(schemes, warnings)
+          @schemes = schemes == :all ? :all : Array(schemes).map { |scheme| scheme.to_s.downcase }
+          @warnings = warnings
+        end
+
+        def allowed?(href)
+          return true if @schemes == :all || href.start_with?("#")
+          return true if @schemes.include?(href[SCHEME, 1].to_s.downcase)
+
+          @warnings << Warnings::DroppedLink.new(href:)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/stationery/rich/renderer.rb

@@ -3,6 +3,7 @@
 require_relative "nodes"
 require_relative "styles"
 require_relative "renderer/inlines"
+require_relative "renderer/links"
 
 module Stationery
   module Rich
@@ -11,8 +12,9 @@ module Stationery
     # from files under `base_path:`; remote URLs are never fetched.
     class Renderer
       REMOTE = /\A[a-z][a-z0-9+.-]*:/i
+      LINK_SCHEMES = %w[http https mailto tel].freeze
 
-      def initialize(component, builder, gap:, styles:, images:, base_path:, bookmarks: false)
+      def initialize(component, builder, gap:, styles:, images:, base_path:, bookmarks: false, links: nil)
         @component = component
         @builder = builder
         @gap = gap
@@ -20,6 +22,7 @@ module Stationery
         @images = images
         @base_path = base_path && File.expand_path(base_path.to_s)
         @bookmarks = bookmarks
+        @links = Links.new(links || LINK_SCHEMES, builder.warnings)
       end
 
       def render(blocks) = @component.group(gap: @gap) { blocks.each { |block| block(block) } }
@@ -40,7 +43,7 @@ module Stationery
       end
 
       def paragraph(inlines, **)
-        @component.text(**) { |runs| Inlines.new(runs, @styles).write(inlines) }
+        @component.text(**) { |runs| Inlines.new(runs, @styles, @links).write(inlines) }
       end
 
       def heading(heading)
@@ -57,7 +60,7 @@ module Stationery
       end
 
       def list(list)
-        options = list.ordered ? { start: list.start || 1 } : {}
+        options = list.ordered ? { **@styles[:ol], start: list.start || 1 } : @styles[:ul]
         @component.public_send(list.ordered ? :ol : :ul, **options) do
           list.items.each do |blocks|
             @component.li { @component.text_style(**@styles[:li]) { render(blocks) } }

data/lib/stationery/rich/styles.rb

@@ -18,6 +18,8 @@ module Stationery
         blockquote: { border: { sides: [:left], width: 3, color: "#E5E7EB" }, padding: [0, 0, 0, 10] },
         hr: { height: 1, color: "#E5E7EB" },
         table: { cell: { padding: 4 }, header: { weight: :bold } },
+        ul: {},
+        ol: {},
         li: {},
         img: { max_width: nil }
       }.freeze

data/lib/stationery/rspec.rb

@@ -3,4 +3,8 @@
 require "stationery"
 require_relative "testing/matchers"
 
+# Composable adds `and`/`or` and lets a matcher sit inside `include`, `match`
+# and `all`; Base stays framework-free for Minitest, so it is mixed in here.
+Stationery::Testing::Matchers::Base.include(RSpec::Matchers::Composable)
+
 RSpec.configure { |config| config.include Stationery::Testing::Matchers }

data/lib/stationery/testing/inspector.rb

@@ -60,16 +60,21 @@ module Stationery
       end
 
       def bookmarks
-        outlines = objects.deref!(objects.trailer[:Root])[:Outlines]
+        outlines = catalog[:Outlines]
         outlines ? titles(outlines[:First]) : []
       end
 
+      # The catalog /Lang written by `metadata lang:`, or nil.
+      def lang
+        lang = catalog[:Lang]
+        decode(lang) if lang
+      end
+
       # The structure tree of a tagged PDF as nested arrays; see StructureReader.
       def structure = @structure ||= StructureReader.new(reader).tree
 
       # Whether the catalog marks the PDF as tagged and holds a structure tree.
       def tagged?
-        catalog = objects.deref!(objects.trailer[:Root])
         catalog.dig(:MarkInfo, :Marked) == true && !catalog[:StructTreeRoot].nil?
       end
 
@@ -81,6 +86,7 @@ module Stationery
       private
 
       def objects = reader.objects
+      def catalog = objects.deref!(objects.trailer[:Root])
 
       def annotations
         reader.pages.flat_map do |page|

data/lib/stationery/testing/matchers.rb

@@ -101,6 +101,15 @@ module Stationery
         def actual = "got bookmarks #{@inspector.bookmarks.inspect}"
       end
 
+      class HaveLanguage < Base
+        def description = "have language #{show(@expected)}"
+
+        private
+
+        def match?(pdf) = pdf.lang == @expected.to_s
+        def actual = @inspector.lang ? "got #{@inspector.lang.inspect}" : "got none"
+      end
+
       class HaveNoWarnings < Base
         def description = "have no warnings"
 
@@ -140,6 +149,7 @@ module Stationery
       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_pdf_language(lang) = HaveLanguage.new(lang)
       def have_no_warnings = HaveNoWarnings.new
       def have_structure(expected) = HaveStructure.new(expected)
       def have_tagged_content = HaveTaggedContent.new

data/lib/stationery/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Stationery
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/stationery/warnings.rb

@@ -33,6 +33,10 @@ module Stationery
       def message = %(link to "#{name}" on page #{page} has no matching anchor)
     end
 
+    DroppedLink = Data.define(:href) do
+      def message = %(link "#{href}" dropped: scheme not allowed)
+    end
+
     DuplicateAnchor = Data.define(:name, :page) do
       def message = %(anchor "#{name}" on page #{page} is already defined)
     end

data/lib/stationery.rb

@@ -2,6 +2,7 @@
 
 require_relative "stationery/version"
 require_relative "stationery/errors"
+require_relative "stationery/instrumentation"
 require_relative "stationery/pdf/types"
 require_relative "stationery/pdf/serializer"
 require_relative "stationery/pdf/stream"
@@ -107,6 +108,7 @@ require_relative "stationery/svg/document"
 require_relative "stationery/layout/svg"
 require_relative "stationery/layout/wrap"
 require_relative "stationery/layout/positioned"
+require_relative "stationery/layout/stack"
 require_relative "stationery/layout/field"
 require_relative "stationery/layout/list_item"
 require_relative "stationery/list_markers"