receipts 2.4.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a074319e14c0aaf9a5e4776d854c90810273092e58d7672046f7a6ef4d01a6d5
-  data.tar.gz: e4d3bf9feb0a135357a6666ca46a8c9298d0d623223101c0649c7c9b2b45248f
+  metadata.gz: a47085bc4aed90ea312b2824ded3d8160c62479d59041b482ff8bb0cdf7776b3
+  data.tar.gz: 7d356f573664804db0684f104f3a8df60549413fc0d16918f9062ede95d604ff
 SHA512:
-  metadata.gz: e22ececba2faf58b41ed4b677bbf351b6dadb51eb0c2e54b9930949eceb7bbc68d29aba7a642e44c47d76d9486669d324cd642befb920576398a13d392e8e303
-  data.tar.gz: 179cbdbf4fbaa3de6de2d1e76a0c9087bc91b9fa36c639f3d5824f112a32a1199662fd0ae87efa3d18f69be6744d3762e495e85cb111e67106a7bde81b90c7e3
+  metadata.gz: 329d7d5947440183086281c55a54e340550783fbbc8f9c21fff7dee0c02b9c6e0a0ba3bd7512efb2a15bf3ce091f0c10b98fe49909e8a09e7208f9a5adc3fd45
+  data.tar.gz: b390f51b8bc9e506b90cc4ab8486f278edde18945f726498faf27c4ab2b022c0e3f31adb4d0793a86992440e1db394ba9d3aaa04889c51b18c1669055587d727

data/.standard.yml

@@ -0,0 +1 @@
+ruby_version: 2.7

data/CHANGELOG.md

@@ -1,6 +1,16 @@
 ### Unreleased
 
-* Add `display: []` for configuring company details that are rendered
+### 3.0.0
+
+* Replace Prawn with a built-in, pure Ruby PDF generator. Receipts no longer has any gem dependencies.
+* Embed the Inter font by default, adding Unicode support (Latin, Greek, Cyrillic) without configuring a custom font
+* Custom fonts must be TrueType (`.ttf`) files; only used characters are embedded
+* **Breaking:** Receipts objects inherit from `Receipts::PDF::Document` instead of `Prawn::Document`. Custom content using Prawn APIs beyond `text`, `image`, `table`, `move_down`/`move_up`, `font`, `font_size`, `bounds` and `start_new_page` needs updating.
+* **Breaking:** Table cells no longer accept Prawn's `overflow:` option. Rows always grow to fit their content, so remove `overflow:` from any custom `cell_style`.
+
+### 2.4.0
+
+* Add `display: []` for configuring company details that are rendered #38 - @excid3
 
 ```ruby
 r = Receipts::Receipt.new(
@@ -17,6 +27,8 @@ r = Receipts::Receipt.new(
 )
 ```
 
+* Fix Prawn docs link in README #36 - @ocarreterom
+
 ### 2.3.0
 
 * Add `column_widths:` option to specify line item column widths #35

data/Gemfile

@@ -6,4 +6,3 @@ gemspec
 gem "minitest", "~> 5.0"
 gem "rake", "~> 13.0"
 gem "standard"
-gem "matrix", "~> 0.4"

data/README.md

@@ -2,7 +2,7 @@
 
 # Receipts Gem
 
-Receipts, Invoices, and Statements for your Rails application that works with any payment provider. Receipts uses Prawn to generate the PDFs.
+Receipts, Invoices, and Statements for your Rails application that works with any payment provider. PDFs are generated in pure Ruby with no dependencies.
 
 Check out the [example PDFs](https://github.com/excid3/receipts/blob/master/examples/).
 
@@ -72,7 +72,9 @@ r.render_file "examples/receipt.pdf"
 
 ### Configuration
 
-You can specify the default font for all PDFs by defining the following in an initializer:
+PDFs use the bundled [Inter](https://rsms.me/inter/) font by default, which supports Latin, Greek, and Cyrillic characters.
+
+You can specify a different default font for all PDFs by defining the following in an initializer:
 
 ```ruby
 Receipts.default_font = {
@@ -81,6 +83,8 @@ Receipts.default_font = {
 }
 ```
 
+Fonts must be TrueType (`.ttf`) files. Only the characters used are embedded in each PDF. You may also provide `italic:` and `bold_italic:` fonts; otherwise italic text is simulated by slanting the normal font.
+
 ### Options
 
 You can pass the following options to generate a PDF:
@@ -132,8 +136,7 @@ Here's an example of where each option is displayed.
 
 #### Line Items Table - Column Widths
 
-You may set an option to configure the line items table's columns width in order to accommodate shortcomings of Prawn's width guessing ability to render header and content reasonably sized.
-The configuration depends on your line item column count and follows the prawn/table configuration as documented [here](https://prawnpdf.org/prawn-table-manual.pdf):
+By default, columns are sized to fit their content and any leftover space is split evenly between columns. You may set the width of specific columns in points (1/72 inch) to override this.
 
 This will size the second column to 400 and the fourth column to 50.
 
@@ -147,13 +150,18 @@ This will set all column widths, considering your table has 4 columns.
 column_widths: [100, 200, 240]
 ```
 
-If not set, it will fall back to Prawn's default behavior.
+Columns without a width are sized automatically.
 
 ### Formatting
 
-`details` and `line_items` allow inline formatting with Prawn. This allows you to use HTML tags to format text: `<b>` `<i>` `<u>` `<strikethrough>` `<sub>` `<sup>` `<font>` `<color>` `<link>`
+`details`, `line_items`, `recipient` and `footer` allow inline formatting using HTML-like tags:
+
+* `<b>` / `<strong>`, `<i>` / `<em>`, `<u>`, `<strikethrough>`, `<sub>`, `<sup>`, `<br>`
+* `<font name="Primary" size="12" character_spacing="1">`
+* `<color rgb="#5eba7d">` or `<color c="0" m="100" y="100" k="0">`
+* `<link href="https://example.com">`
 
-See [the Prawn docs](https://prawnpdf.org/) for more information.
+Use `&lt;`, `&gt;` and `&amp;` for literal `<`, `>` and `&` characters.
 
 #### Page Size
 
@@ -183,17 +191,28 @@ You can change the entire PDF content by instantiating an Receipts object withou
 receipt = Receipts::Receipt.new # creates an empty PDF
 ```
 
-Each Receipts object inherits from Prawn::Document. This allows you to choose what is rendered and include any custom Prawn content you like.
+Each Receipts object inherits from `Receipts::PDF::Document`, which provides a small, Prawn-like API for adding your own content:
 
 ```ruby
-receipt.text("hello world")
+receipt.text("hello world", size: 12, style: :bold, align: :center, color: "4b5563")
+receipt.text("<b>Bold</b> and <i>italic</i>", inline_format: true)
+receipt.move_down 20
+receipt.image "logo.png", height: 24, position: :right
+receipt.table([["Item", "Amount"], ["Product", "$10"]], width: receipt.bounds.width) do
+  row(0).font_style = :bold
+  column(1).align = :right
+end
+receipt.stroke_horizontal_rule
+receipt.start_new_page
 ```
 
+Images must be PNG (non-interlaced) or JPEG files.
+
 You can also use the Receipts helpers in your custom PDFs at the current cursor position.
 
 ```ruby
 receipt.text("Custom header")
-receipt.render_line_items([
+receipt.render_line_items(line_items: [
   ["my line items"]
 ])
 receipt.render_footer("This is a custom footer using the Receipts helper")

data/lib/receipts/base.rb

@@ -1,5 +1,5 @@
 module Receipts
-  class Base < Prawn::Document
+  class Base < PDF::Document
     attr_accessor :title, :company
 
     class << self
@@ -39,11 +39,7 @@ module Receipts
     end
 
     def load_image(logo)
-      if logo.is_a? String
-        logo.start_with?("http") ? URI.parse(logo).open : File.open(logo)
-      else
-        logo
-      end
+      (logo.is_a?(String) && logo.start_with?("http")) ? URI.parse(logo).open : logo
     end
 
     def header(company: {}, height: 16)
@@ -76,7 +72,7 @@ module Receipts
           {content: Array(recipient).join("\n"), padding: [0, 12, 0, 0]}
         ]
       ]
-      table(line_items, width: bounds.width, cell_style: {borders: [], inline_format: true, overflow: :expand})
+      table(line_items, width: bounds.width, cell_style: {borders: [], inline_format: true})
     end
 
     def render_line_items(line_items:, margin_top: 30, column_widths: nil)

data/lib/receipts/fonts/OFL.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

data/lib/receipts/pdf/document.rb

@@ -0,0 +1,383 @@
+module Receipts
+  module PDF
+    # A minimal PDF document with a Prawn-like API for flowing text, images and tables.
+    #
+    # Coordinates follow PDF conventions: the origin is the bottom left of the page
+    # and units are points (1/72 inch).
+    class Document
+      PAGE_SIZES = {
+        "A3" => [841.89, 1190.55],
+        "A4" => [595.28, 841.89],
+        "A5" => [419.53, 595.28],
+        "LEGAL" => [612.0, 1008.0],
+        "LETTER" => [612.0, 792.0],
+        "TABLOID" => [792.0, 1224.0]
+      }.freeze
+
+      FONTS_PATH = File.expand_path("../fonts", __dir__)
+      DEFAULT_FONT_FAMILY = "Inter"
+      DEFAULT_FONT = {
+        normal: File.join(FONTS_PATH, "Inter-Regular.ttf"),
+        bold: File.join(FONTS_PATH, "Inter-Bold.ttf")
+      }.freeze
+
+      # The area inside the page margins. Like Prawn, `left`, `right`, `top` and
+      # `bottom` are relative to the box, while the absolute_* values are page coordinates.
+      Bounds = Struct.new(:absolute_left, :absolute_bottom, :width, :height) do
+        def left
+          0
+        end
+
+        def bottom
+          0
+        end
+
+        def right
+          width
+        end
+
+        def top
+          height
+        end
+
+        def absolute_right
+          absolute_left + width
+        end
+
+        def absolute_top
+          absolute_bottom + height
+        end
+      end
+
+      Page = Struct.new(:content, :annotations)
+
+      attr_reader :bounds, :font_families, :page_width, :page_height
+      attr_accessor :y, :fill_color, :stroke_color, :line_width
+
+      def initialize(page_size: "LETTER", page_layout: :portrait, margin: 36, info: {})
+        width, height = page_size.is_a?(Array) ? page_size : PAGE_SIZES.fetch(page_size.to_s.upcase) {
+          raise ArgumentError, "unknown page size #{page_size.inspect}, use one of #{PAGE_SIZES.keys.join(", ")} or [width, height]"
+        }
+        width, height = height, width if page_layout == :landscape
+        @page_width = width
+        @page_height = height
+
+        top, right, bottom, left = Geometry.expand_box(margin)
+        @bounds = Bounds.new(left, bottom, width - left - right, height - top - bottom)
+
+        @info = info
+        @font_families = {DEFAULT_FONT_FAMILY => DEFAULT_FONT.dup}
+        @font_family = DEFAULT_FONT_FAMILY
+        @font_size = 12
+        @fill_color = "000000"
+        @stroke_color = "000000"
+        @line_width = 1
+        @fonts = {}
+        @font_resources = {}.compare_by_identity
+        @images = {}.compare_by_identity
+        @pages = []
+
+        start_new_page
+      end
+
+      def start_new_page
+        @pages << Page.new(String.new(encoding: Encoding::BINARY), [])
+        @y = @bounds.absolute_top
+      end
+
+      # Starts a new page if there isn't room for height, unless already at the top of one.
+      # Returns true when a new page was started.
+      def start_new_page_if_needed(height)
+        return false unless @y - height < @bounds.absolute_bottom && @y < @bounds.absolute_top
+        start_new_page
+        true
+      end
+
+      def page_count
+        @pages.size
+      end
+
+      # Distance from the current position to the bottom margin
+      def cursor
+        @y - @bounds.absolute_bottom
+      end
+
+      def move_down(amount)
+        @y -= amount
+      end
+
+      def move_up(amount)
+        @y += amount
+      end
+
+      def move_cursor_to(position)
+        @y = @bounds.absolute_bottom + position
+      end
+
+      # Sets the font family (or a path to a .ttf file), optionally just for the given block
+      def font(name = nil, size: nil)
+        return @font_family if name.nil? && size.nil?
+
+        previous = [@font_family, @font_size]
+        @font_family = name.to_s if name
+        @font_size = size if size
+        return unless block_given?
+
+        begin
+          yield
+        ensure
+          @font_family, @font_size = previous
+        end
+      end
+
+      def font_size(size = nil, &block)
+        return @font_size if size.nil?
+        return @font_size = size unless block
+        font(nil, size: size, &block)
+      end
+
+      def width_of(string, options = {})
+        TextLayout.natural_width(text_chunks(string, options), text_style(options))
+      end
+
+      def height_of(string, options = {})
+        TextLayout.height_of(text_lines(string, options, @bounds.width), options.fetch(:leading, 0))
+      end
+
+      # Writes flowing text at the cursor, wrapping lines and starting new pages as needed.
+      #
+      # Options: :size, :style (:bold, :italic, :bold_italic), :align (:left, :center, :right),
+      # :color (hex RGB), :font, :character_spacing, :leading, :inline_format
+      def text(string, options = {})
+        lines = text_lines(string, options, @bounds.width)
+        leading = options.fetch(:leading, 0)
+
+        lines.each_with_index do |line, index|
+          start_new_page_if_needed(line.height)
+          draw_text_line(line, @bounds.absolute_left, @y - line.ascender, @bounds.width, options.fetch(:align, :left))
+          @y -= line.height
+          @y -= line.line_gap + leading if index < lines.size - 1
+        end
+        nil
+      end
+
+      # Draws an image at the cursor. Given only a width or height, the other is
+      # scaled proportionally. Given neither, images wider than the bounds are scaled down to fit.
+      #
+      # Position is :left, :center, :right or an x offset from the left bound.
+      def image(source, width: nil, height: nil, position: :left)
+        image = Image.load(source)
+        width ||= height ? image.width * height.to_f / image.height : [image.width, @bounds.width].min.to_f
+        height ||= image.height * width.to_f / image.width
+        x = @bounds.absolute_left + Geometry.align_offset(position, @bounds.width, width)
+
+        start_new_page_if_needed(height)
+
+        name = @images[image] ||= :"I#{@images.size + 1}"
+        add_content "q #{n(width)} 0 0 #{n(height)} #{n(x)} #{n(@y - height)} cm /#{name} Do Q"
+        @y -= height
+        nil
+      end
+
+      # Draws a table at the cursor. See Receipts::PDF::Table for options.
+      def table(data, options = {}, &block)
+        Table.new(self, data, options, &block).draw
+      end
+
+      def stroke_horizontal_rule
+        stroke_line(@bounds.absolute_left, @y, @bounds.absolute_right, @y)
+      end
+
+      def stroke_line(x1, y1, x2, y2, color: @stroke_color, width: @line_width)
+        add_content "q #{color_operator(color, stroke: true)} #{n(width)} w #{n(x1)} #{n(y1)} m #{n(x2)} #{n(y2)} l S Q"
+      end
+
+      def fill_rectangle(x, y, width, height, color: @fill_color)
+        add_content "q #{color_operator(color)} #{n(x)} #{n(y)} #{n(width)} #{n(height)} re f Q"
+      end
+
+      def render
+        writer = Writer.new
+
+        fonts = @font_resources.map { |font, name| [name, font.build(writer)] }.to_h
+        images = @images.map { |image, name| [name, image.build(writer)] }.to_h
+        resources = {}
+        resources[:Font] = fonts if fonts.any?
+        resources[:XObject] = images if images.any?
+        resources = writer.add(resources)
+
+        pages = writer.reserve
+        kids = @pages.map do |page|
+          dictionary = {
+            Type: :Page,
+            Parent: pages,
+            MediaBox: [0, 0, @page_width, @page_height],
+            Resources: resources,
+            Contents: writer.add(Stream.new(page.content))
+          }
+          dictionary[:Annots] = page.annotations.map { |annotation| writer.add(annotation) } if page.annotations.any?
+          writer.add(dictionary)
+        end
+        writer.set(pages, Type: :Pages, Kids: kids, Count: kids.size)
+
+        info = {Producer: "Receipts"}.merge(@info).transform_values { |value| Serializer.text_string(value) }
+        writer.render(root: writer.add(Type: :Catalog, Pages: pages), info: writer.add(info))
+      end
+
+      def render_file(path)
+        File.binwrite(path, render)
+      end
+
+      # [natural width, widest word] of text, used to size table columns
+      def measure_text(string, options = {})
+        chunks = text_chunks(string, options)
+        style = text_style(options)
+        [TextLayout.natural_width(chunks, style), TextLayout.minimum_width(chunks, style)]
+      end
+
+      # Lays out text into lines for the given width without drawing it
+      def text_lines(string, options, width)
+        TextLayout.wrap(text_chunks(string, options), width, text_style(options))
+      end
+
+      # Draws lines of text top-down from top, returning the height used
+      def draw_text_lines(lines, x, top, width, align: :left, leading: 0)
+        y = top
+        lines.each_with_index do |line, index|
+          draw_text_line(line, x, y - line.ascender, width, align)
+          y -= line.height
+          y -= line.line_gap + leading if index < lines.size - 1
+        end
+        top - y
+      end
+
+      private
+
+      def add_content(operators)
+        @pages.last.content << operators << "\n"
+      end
+
+      def n(value)
+        Serializer.number(value)
+      end
+
+      def text_style(options, fragment = {})
+        styles = style_list(options[:style]) | Array(fragment[:styles])
+        size = fragment[:size] || options[:size] || @font_size
+        rise = 0
+
+        if styles.include?(:superscript)
+          rise = size * 0.33
+          size *= 0.583
+        elsif styles.include?(:subscript)
+          rise = -size * 0.2
+          size *= 0.583
+        end
+
+        font, fake_bold, oblique = resolve_font(fragment[:font] || options[:font] || @font_family, styles)
+
+        TextLayout::Style.new(
+          font: font,
+          size: size,
+          color: fragment[:color] || options[:color] || @fill_color,
+          link: fragment[:link],
+          underline: styles.include?(:underline),
+          strikethrough: styles.include?(:strikethrough),
+          rise: rise,
+          character_spacing: fragment[:character_spacing] || options[:character_spacing] || 0,
+          oblique: oblique,
+          fake_bold: fake_bold
+        )
+      end
+
+      def text_chunks(string, options)
+        string = string.to_s
+        string = string.dup.force_encoding(Encoding::UTF_8) if string.encoding == Encoding::BINARY
+        string = string.encode(Encoding::UTF_8, invalid: :replace, undef: :replace).scrub.delete("\r")
+
+        fragments = options[:inline_format] ? InlineFormat.parse(string) : [{text: string}]
+        fragments.map { |fragment| [fragment[:text], text_style(options, fragment)] }
+      end
+
+      def style_list(style)
+        case style
+        when nil, :normal then []
+        when :bold_italic then [:bold, :italic]
+        when Array then style
+        else [style.to_sym]
+        end
+      end
+
+      # Picks the font for a style, faking bold or italic when the family doesn't include it.
+      # Returns [font, fake_bold, oblique]
+      def resolve_font(name, styles)
+        name = name.to_s
+        family = @font_families[name] || (name.end_with?(".ttf") && File.exist?(name) && {normal: name})
+        raise ArgumentError, "unknown font #{name.inspect}, register it with font_families.update(#{name.inspect} => {normal: \"path/to/font.ttf\"})" unless family
+
+        family = family.transform_keys(&:to_sym)
+        bold = styles.include?(:bold)
+        italic = styles.include?(:italic)
+        key = [(:bold_italic if bold && italic), (:bold if bold), (:italic if italic), :normal].compact.find { |style| family[style] }
+        raise ArgumentError, "font family #{name.inspect} needs a :normal font" unless key
+
+        path = File.expand_path(family[key].to_s)
+        font = @fonts[path] ||= Font.new(path).tap { |f| @font_resources[f] = :"F#{@font_resources.size + 1}" }
+        [font, bold && !key.to_s.include?("bold"), italic && !key.to_s.include?("italic")]
+      end
+
+      def draw_text_line(line, x, baseline, width, align)
+        x += Geometry.align_offset(align, width, line.width)
+
+        line.runs.each do |run|
+          draw_run(run, x, baseline)
+          x += run.width
+        end
+      end
+
+      def draw_run(run, x, baseline)
+        style = run.style
+        y = baseline + style.rise
+
+        ops = ["q BT", "/#{@font_resources.fetch(style.font)} #{n(style.size)} Tf", color_operator(style.color)]
+        ops << "#{n(style.character_spacing)} Tc" unless style.character_spacing.zero?
+        ops << "2 Tr #{n(style.size * 0.03)} w #{color_operator(style.color, stroke: true)}" if style.fake_bold
+        ops << "1 0 #{style.oblique ? n(Font::OBLIQUE_SKEW) : 0} 1 #{n(x)} #{n(y)} Tm"
+        ops << "<#{style.font.encode(run.text).unpack1("H*")}> Tj ET Q"
+        add_content ops.join(" ")
+
+        font = style.font
+        stroke_decoration(run, x, y, font.underline_position(style.size), font.underline_thickness(style.size)) if style.underline
+        stroke_decoration(run, x, y, font.strikeout_position(style.size), font.strikeout_size(style.size)) if style.strikethrough
+
+        if style.link
+          @pages.last.annotations << {
+            Type: :Annot,
+            Subtype: :Link,
+            Rect: [x, y - style.font.descender(style.size), x + run.width, y + style.font.ascender(style.size)],
+            Border: [0, 0, 0],
+            A: {Type: :Action, S: :URI, URI: style.link.to_s}
+          }
+        end
+      end
+
+      # Draws an underline or strikethrough line across a run at an offset from its baseline
+      def stroke_decoration(run, x, baseline, offset, thickness)
+        y = baseline + offset
+        stroke_line(x, y, x + run.width, y, color: run.style.color, width: thickness)
+      end
+
+      # Hex RGB ("ff0000" or "#ff0000") or CMYK percentages ([0, 100, 100, 0])
+      def color_operator(color, stroke: false)
+        if color.is_a?(Array)
+          "#{color.map { |c| n(c / 100.0) }.join(" ")} #{stroke ? "K" : "k"}"
+        else
+          hex = color.to_s.delete("#")
+          hex = hex.chars.map { |c| c * 2 }.join if hex.size == 3
+          raise ArgumentError, "invalid color #{color.inspect}" unless hex.match?(/\A\h{6}\z/)
+          "#{[hex].pack("H*").bytes.map { |c| n(c / 255.0) }.join(" ")} #{stroke ? "RG" : "rg"}"
+        end
+      end
+    end
+  end
+end