stationery 0.1.0

data/lib/stationery/text/markup.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Stationery
+  module Text
+    # Parses Prawn-style inline markup into runs:
+    #
+    #   <b> <strong> <i> <em> <u> <strikethrough> <s> <del> <sub> <sup> <br>
+    #   <color rgb="#hex"> <color c="" m="" y="" k="">
+    #   <font size="n" name="Family"> <link href="…"> <a href="…">
+    #
+    # Unknown tags are dropped and their content kept. A "<" that does not open
+    # a well-formed tag is text, so "1 < 2" survives.
+    class Markup
+      TAG = %r{<(/?)([a-zA-Z][a-zA-Z0-9]*)((?:\s+[a-zA-Z_:-]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>"']+))*)\s*/?>}
+      ATTRIBUTE = /([a-zA-Z_:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>"']+))/
+      STYLES = {
+        "b" => { weight: :bold }, "strong" => { weight: :bold },
+        "i" => { style: :italic }, "em" => { style: :italic },
+        "u" => { underline: true },
+        "strikethrough" => { strikethrough: true }, "s" => { strikethrough: true }, "del" => { strikethrough: true },
+        "sub" => { script: :sub }, "sup" => { script: :sup }
+      }.freeze
+
+      def self.parse(source, style)
+        new(source, style).runs
+      end
+
+      def initialize(source, style)
+        @scanner = StringScanner.new(source.to_s)
+        @stack = [[nil, style]]
+        @runs = []
+      end
+
+      def runs
+        until @scanner.eos?
+          if (text = @scanner.scan(/[^<]+/))
+            emit(Entities.decode(text))
+          elsif @scanner.check(TAG)
+            tag(@scanner.scan(TAG))
+          else
+            emit(@scanner.getch)
+          end
+        end
+        Run.merge(@runs)
+      end
+
+      private
+
+      def emit(text)
+        @runs << Run.new(text, @stack.last.last)
+      end
+
+      def tag(source)
+        closing, name, attributes = source.match(TAG).captures
+        name = name.downcase
+        return emit("\n") if name == "br"
+        return close(name) if closing == "/"
+
+        overrides = overrides_for(name, attributes(attributes))
+        @stack << [name, @stack.last.last.with(**overrides)] if overrides
+      end
+
+      def close(name)
+        index = @stack.rindex { |tag_name, _| tag_name == name }
+        @stack.slice!(index..) if index&.positive?
+      end
+
+      def overrides_for(name, attributes)
+        return STYLES[name] if STYLES.key?(name)
+
+        case name
+        when "color" then color(attributes)
+        when "font" then font(attributes)
+        when "link", "a" then attributes["href"] ? { link: attributes["href"] } : {}
+        end
+      end
+
+      def color(attributes)
+        return { color: attributes["rgb"] } if attributes["rgb"]
+        return {} unless %w[c m y k].all? { |key| attributes.key?(key) }
+
+        { color: %w[c m y k].map { |key| number(attributes[key]) } }
+      end
+
+      def font(attributes)
+        overrides = {}
+        overrides[:size] = number(attributes["size"]) if attributes["size"]
+        overrides[:family] = attributes["name"] if attributes["name"]
+        overrides
+      end
+
+      def attributes(source)
+        source.scan(ATTRIBUTE).to_h { |key, *values| [key.downcase, Entities.decode(values.compact.first)] }
+      end
+
+      def number(value)
+        value.include?(".") ? value.to_f : value.to_i
+      end
+    end
+  end
+end

data/lib/stationery/text/paragraph.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    # Wrapped lines of runs at a width, ready to measure, split across pages
+    # and draw.
+    class Paragraph
+      MIN_SHRINK_SIZE = 4
+
+      attr_reader :runs, :lines, :width, :align, :leading
+
+      def initialize(runs, book:, width:, align: :left, leading: 0, lines: nil, fallback_style: nil)
+        @runs = runs
+        @book = book
+        @width = width
+        @align = align
+        @leading = leading
+        @fallback_style = fallback_style || runs.first&.style
+        @lines = lines || Wrapper.new(book).wrap(runs, width, fallback_style: @fallback_style)
+      end
+
+      def height
+        return 0 if @lines.empty?
+
+        @lines.sum(&:height) + (@leading * (@lines.size - 1))
+      end
+
+      # [fits, rest] by whole lines; nil for an empty side.
+      def split(max_height)
+        count = fitting_lines(max_height)
+        return [self, nil] if count == @lines.size
+        return [nil, self] if count.zero?
+
+        [with_lines(@lines.first(count)), with_lines(@lines.drop(count))]
+      end
+
+      # A paragraph that fits `max_height`: truncated to whole lines, shrunk
+      # (never below 4pt) or left as is for :visible.
+      def fit(max_height, overflow:)
+        return self if overflow == :visible || height <= max_height
+        return split(max_height).first || with_lines([]) if overflow == :truncate
+
+        shrink(max_height)
+      end
+
+      def draw(canvas, x, y)
+        top = y
+        @lines.each do |line|
+          offset = x + Geometry.align_offset(@align, @width, line.width)
+          line.fragments.each { |fragment| draw_fragment(canvas, fragment, offset, top, line) }
+          top += line.height + @leading
+        end
+      end
+
+      private
+
+      def fitting_lines(max_height)
+        used = 0
+        @lines.take_while.with_index do |line, index|
+          used += line.height + (index.zero? ? 0 : @leading)
+          used <= max_height + 0.0001
+        end.size
+      end
+
+      def with_lines(lines)
+        self.class.new(@runs, book: @book, width: @width, align: @align, leading: @leading, lines:,
+                              fallback_style: @fallback_style)
+      end
+
+      def shrink(max_height)
+        factor = 1.0
+        loop do
+          factor -= 0.05
+          scaled = scaled_runs(factor)
+          candidate = self.class.new(scaled, book: @book, width: @width, align: @align, leading: @leading * factor,
+                                             fallback_style: scaled.first&.style || @fallback_style)
+          return candidate if candidate.height <= max_height || scaled.all? { |run| run.style.size <= MIN_SHRINK_SIZE }
+        end
+      end
+
+      def scaled_runs(factor)
+        @runs.map { |run| Run.new(run.text, run.style.with(size: [run.style.size * factor, MIN_SHRINK_SIZE].max)) }
+      end
+
+      def draw_fragment(canvas, fragment, offset, top, line)
+        style = fragment.style
+        x = offset + fragment.x
+        canvas.text(fragment.text, x:, y: top + line.ascent, font: fragment.font, size: style.render_size,
+                                   color: style.color, letter_spacing: style.letter_spacing, rise: style.rise,
+                                   opacity: style.opacity, underline: style.underline,
+                                   strikethrough: style.strikethrough,
+                                   synthetic_bold: fragment.face.synthetic_bold,
+                                   synthetic_oblique: fragment.face.synthetic_oblique)
+        canvas.link(x, top, fragment.width, line.height, style.link) if style.link
+      end
+    end
+  end
+end

data/lib/stationery/text/runs_builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    # Builds runs with Ruby instead of markup:
+    #
+    #   text { plain "Total "; b "due"; link("https://…") { i "pay" } }
+    class RunsBuilder
+      def self.build(style, &)
+        new(style).tap { |builder| builder.capture(&) }.runs
+      end
+
+      def initialize(style)
+        @styles = [style]
+        @runs = []
+      end
+
+      def runs = Run.merge(@runs)
+
+      # A block taking an argument is called with the builder (so it keeps its
+      # own self and instance variables); one without is evaluated on it.
+      def capture(&block)
+        before = @runs.size
+        result = block.arity == 1 ? yield(self) : instance_exec(&block)
+        plain(result) if result.is_a?(String) && @runs.size == before
+      end
+
+      def plain(text) = @runs << Run.new(text.to_s, @styles.last)
+      def br = plain("\n")
+
+      def b(text = nil, &) = styled({ weight: :bold }, text, &)
+      def i(text = nil, &) = styled({ style: :italic }, text, &)
+      def u(text = nil, &) = styled({ underline: true }, text, &)
+      def strikethrough(text = nil, &) = styled({ strikethrough: true }, text, &)
+      def sub(text = nil, &) = styled({ script: :sub }, text, &)
+      def sup(text = nil, &) = styled({ script: :sup }, text, &)
+      def color(value, text = nil, &) = styled({ color: value }, text, &)
+      def size(value, text = nil, &) = styled({ size: value }, text, &)
+      def font(family, text = nil, &) = styled({ family: family.to_s }, text, &)
+      def link(url, text = nil, &) = styled({ link: url.to_s }, text, &)
+
+      private
+
+      def styled(overrides, text, &)
+        @styles << @styles.last.with(**overrides)
+        text ? plain(text) : capture(&)
+      ensure
+        @styles.pop
+      end
+    end
+  end
+end

data/lib/stationery/text/style.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    SCRIPT_SCALE = 0.583
+
+    # How a run of text looks. Immutable; derive variants with #with.
+    Style = Data.define(:family, :size, :weight, :style, :color, :letter_spacing,
+                        :underline, :strikethrough, :script, :link, :opacity) do
+      def initialize(family:, size: 10, weight: :regular, style: :normal, color: "#000000", letter_spacing: 0,
+                     underline: false, strikethrough: false, script: nil, link: nil, opacity: nil)
+        super
+      end
+
+      # The size glyphs are drawn at: smaller for sub- and superscript.
+      def render_size
+        script ? size * SCRIPT_SCALE : size
+      end
+
+      # Baseline shift for sub- and superscript.
+      def rise
+        case script
+        when :sup then size * 0.33
+        when :sub then -size * 0.15
+        else 0
+        end
+      end
+    end
+
+    # A piece of text in one style.
+    Run = Data.define(:text, :style) do
+      # Joins neighbouring runs that share a style.
+      def self.merge(runs)
+        runs.each_with_object([]) do |run, merged|
+          next if run.text.empty?
+
+          if merged.last&.style == run.style
+            merged[-1] = Run.new(merged.last.text + run.text, run.style)
+          else
+            merged << run
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stationery/text/wrapper.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    # Greedy line breaking over styled runs. Breaks at spaces (the space is
+    # dropped at the break) and after hyphens; a word wider than the line is
+    # broken between characters. A word that changes style midway ("<b>Tot</b>al")
+    # is still one word.
+    class Wrapper
+      TOKEN = /\n|[ \t]+|[^ \t\n-]*-+|[^ \t\n-]+/
+
+      Segment = Data.define(:text, :style)
+
+      def initialize(book)
+        @book = book
+      end
+
+      def wrap(runs, max_width, fallback_style: runs.first&.style)
+        @max = max_width
+        @lines = []
+        @current = []
+        @pending_space = []
+        @fallback = fallback_style
+        items(runs).each { |item| place(item) }
+        finish unless @current.empty? && @lines.any? && !@ended_with_newline
+        @lines
+      end
+
+      private
+
+      # [:word, segments] | [:space, segments] | [:newline]
+      def items(runs)
+        items = []
+        runs.each do |run|
+          run.text.scan(TOKEN) do |token|
+            if token == "\n" then items << [:newline]
+            elsif token.match?(/\A[ \t]/) then items << [:space, [Segment.new(token, run.style)]]
+            elsif items.last&.first == :word && !items.last.last.last.text.end_with?("-")
+              items.last.last << Segment.new(token, run.style)
+            else items << [:word, [Segment.new(token, run.style)]]
+            end
+          end
+        end
+        items
+      end
+
+      def place((kind, segments))
+        @ended_with_newline = kind == :newline
+        case kind
+        when :newline then finish
+        when :space then @pending_space += segments
+        else place_word(segments)
+        end
+      end
+
+      def place_word(word)
+        needed = width(@pending_space) + width(word)
+        if @current.empty? || line_width + needed <= @max + 0.0001
+          @current.concat(@pending_space, word)
+        else
+          finish(wrapped: true)
+          @current.concat(word)
+        end
+        @pending_space = []
+        break_long_word while line_width > @max + 0.0001 && characters(@current) > 1
+      end
+
+      # Moves characters that overflow the line onto following lines.
+      def break_long_word
+        fitting = []
+        @current.each do |segment|
+          segment.text.each_char do |char|
+            piece = Segment.new(char, segment.style)
+            return keep_overflow(fitting, piece) if fitting.any? && width(fitting + [piece]) > @max + 0.0001
+
+            fitting << piece
+          end
+        end
+      end
+
+      def keep_overflow(fitting, piece)
+        rest = remaining_after(fitting.size)
+        @current = fitting
+        finish(wrapped: true)
+        @current = [piece, *rest.drop(1)]
+      end
+
+      def remaining_after(count)
+        @current.flat_map { |segment| segment.text.chars.map { |char| Segment.new(char, segment.style) } }.drop(count)
+      end
+
+      def finish(wrapped: false)
+        segments = wrapped ? @current : @current + @pending_space
+        @lines << Line.new(fragments(trim_trailing(segments)), fallback_metrics)
+        @current = []
+        @pending_space = []
+      end
+
+      def trim_trailing(segments)
+        segments = segments.dup
+        segments.pop while segments.last && segments.last.text.strip.empty?
+        segments
+      end
+
+      def fragments(segments)
+        x = 0
+        segments.chunk_while { |a, b| a.style == b.style }.map do |group|
+          text = group.map(&:text).join
+          font, face = @book.resolve(group.first.style)
+          fragment_width = measure(text, group.first.style)
+          Fragment.new(text, group.first.style, font, face, fragment_width, x).tap { x += fragment_width }
+        end
+      end
+
+      def fallback_metrics
+        [@book.resolve(@fallback).first, @fallback.render_size]
+      end
+
+      def line_width = width(@current)
+      def characters(segments) = segments.sum { |segment| segment.text.length }
+
+      def width(segments)
+        segments.sum { |segment| measure(segment.text, segment.style) }
+      end
+
+      def measure(text, style)
+        @book.resolve(style).first.width_of(text, style.render_size, letter_spacing: style.letter_spacing)
+      end
+    end
+  end
+end

data/lib/stationery/version.rb

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

data/lib/stationery.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "stationery/version"
+require_relative "stationery/errors"
+require_relative "stationery/pdf/types"
+require_relative "stationery/pdf/serializer"
+require_relative "stationery/pdf/stream"
+require_relative "stationery/pdf/writer"
+require_relative "stationery/fonts/true_type"
+require_relative "stationery/fonts/cmap"
+require_relative "stationery/fonts/name_table"
+require_relative "stationery/fonts/subset"
+require_relative "stationery/fonts/registry"
+require_relative "stationery/fonts/font"
+require_relative "stationery/fonts/family"
+require_relative "stationery/images/images"
+require_relative "stationery/images/cache"
+require_relative "stationery/images/scanlines"
+require_relative "stationery/images/jpeg"
+require_relative "stationery/images/png"
+require_relative "stationery/color"
+require_relative "stationery/geometry"
+require_relative "stationery/page"
+require_relative "stationery/resources"
+require_relative "stationery/canvas/path"
+require_relative "stationery/canvas/text"
+require_relative "stationery/canvas"
+require_relative "stationery/pdf/assembler"
+require_relative "stationery/text/style"
+require_relative "stationery/fonts/font_book"
+require_relative "stationery/text/entities"
+require_relative "stationery/text/markup"
+require_relative "stationery/text/runs_builder"
+require_relative "stationery/text/line"
+require_relative "stationery/text/wrapper"
+require_relative "stationery/text/paragraph"
+require_relative "stationery/layout/node"
+require_relative "stationery/layout/flow"
+require_relative "stationery/layout/box"
+require_relative "stationery/layout/row"
+require_relative "stationery/layout/text"
+require_relative "stationery/layout/image"
+require_relative "stationery/layout/leaves"
+require_relative "stationery/layout/table"
+require_relative "stationery/layout/table/widths"
+require_relative "stationery/layout/table/cell"
+require_relative "stationery/layout/table/selection"
+require_relative "stationery/layout/paginator"
+require_relative "stationery/layout/positioned"
+require_relative "stationery/builder"
+require_relative "stationery/elements"
+require_relative "stationery/component"
+require_relative "stationery/page_templates"
+require_relative "stationery/document"
+
+# Pure-Ruby PDF documents built from Phlex-style components.
+module Stationery
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: stationery
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mikael Henriksson
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Stationery renders PDF documents from Phlex-style Ruby components. Describe
+  the page with rows, columns, boxes, tables, text and images; a box-layout
+  engine measures, places and paginates them, and a small PDF writer embeds
+  subsetted TrueType fonts and JPEG/PNG images. It has no runtime dependencies,
+  no native extensions and never starts another process — no Prawn, no
+  headless browser.
+email:
+- mikael@mhenrixon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/stationery.rb
+- lib/stationery/builder.rb
+- lib/stationery/canvas.rb
+- lib/stationery/canvas/path.rb
+- lib/stationery/canvas/text.rb
+- lib/stationery/color.rb
+- lib/stationery/component.rb
+- lib/stationery/document.rb
+- lib/stationery/elements.rb
+- lib/stationery/errors.rb
+- lib/stationery/fonts/cmap.rb
+- lib/stationery/fonts/family.rb
+- lib/stationery/fonts/font.rb
+- lib/stationery/fonts/font_book.rb
+- lib/stationery/fonts/name_table.rb
+- lib/stationery/fonts/registry.rb
+- lib/stationery/fonts/subset.rb
+- lib/stationery/fonts/true_type.rb
+- lib/stationery/geometry.rb
+- lib/stationery/images/cache.rb
+- lib/stationery/images/images.rb
+- lib/stationery/images/jpeg.rb
+- lib/stationery/images/png.rb
+- lib/stationery/images/scanlines.rb
+- lib/stationery/layout/box.rb
+- lib/stationery/layout/flow.rb
+- lib/stationery/layout/image.rb
+- lib/stationery/layout/leaves.rb
+- lib/stationery/layout/node.rb
+- lib/stationery/layout/paginator.rb
+- lib/stationery/layout/positioned.rb
+- lib/stationery/layout/row.rb
+- lib/stationery/layout/table.rb
+- lib/stationery/layout/table/cell.rb
+- lib/stationery/layout/table/selection.rb
+- lib/stationery/layout/table/widths.rb
+- lib/stationery/layout/text.rb
+- lib/stationery/page.rb
+- lib/stationery/page_templates.rb
+- lib/stationery/pdf/assembler.rb
+- lib/stationery/pdf/serializer.rb
+- lib/stationery/pdf/stream.rb
+- lib/stationery/pdf/types.rb
+- lib/stationery/pdf/writer.rb
+- lib/stationery/rails.rb
+- lib/stationery/resources.rb
+- lib/stationery/text/entities.rb
+- lib/stationery/text/line.rb
+- lib/stationery/text/markup.rb
+- lib/stationery/text/paragraph.rb
+- lib/stationery/text/runs_builder.rb
+- lib/stationery/text/style.rb
+- lib/stationery/text/wrapper.rb
+- lib/stationery/version.rb
+homepage: https://github.com/zoolutions/stationery
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/zoolutions/stationery
+  source_code_uri: https://github.com/zoolutions/stationery/tree/main
+  changelog_uri: https://github.com/zoolutions/stationery/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: 'Pure-Ruby, Phlex-style PDF documents: box layout, TrueType fonts, images.
+  No Prawn, no Chrome.'
+test_files: []