jot_pdf 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3d54ecbe709e2588c085509efb20725711f4d5a3480d1767c5f5131c63c28437
+  data.tar.gz: 3189d100f3c69f510edcc26104052280b52462880e01e0d16133895ddb63ba51
+SHA512:
+  metadata.gz: fce06e57874121739df0f30b446e19693b121259b2898fa302e08a79d875cc1bd440824e05eb7614715e9ad3f4c207bd80d2d53cadfa0f49f6d24438f15deebe
+  data.tar.gz: 46372e13fb42152db255094a8822fd7431dac84b59ba5fc9ee3e51ffc27f35f45ae0c0d0ecb2d5aff1cf6f99315b2e76cc231a6d157e49e25e060cba5fa44195

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,63 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Naming/BlockForwarding:
+  EnforcedStyle: explicit
+
+Style/ArgumentsForwarding:
+  UseAnonymousForwarding: false
+
+Style/Semicolon:
+  AllowAsExpressionSeparator: true
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Lint/AmbiguousOperatorPrecedence:
+  Enabled: false
+
+Lint/EmptyBlock:
+  Enabled: false
+
+# TODO: enable this
+Style/Documentation:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-12-29
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 coord_e
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# JotPDF
+
+Streaming PDF writer DSL for Ruby. Check out a live-editing demo with ruby.wasm: https://jotpdf.coord-e.dev/
+
+## Status
+
+JotPDF is in its early stages, and the API is fairly unstable.
+
+## Usage
+
+```ruby
+# Gemfile
+gem 'jot_pdf'
+```
+
+JotPDF offers two types of DSLs. One is `JotPDF::Core`, a low-level API that directly exposes the structure of PDFs. The other is `JotPDF::Document`, a relatively high-level API built on top of `JotPDF::Core`, designed to be useful for actual document generation.
+
+### JotPDF::Core
+
+A PDF consists of a header, object definitions, `xref` (cross-reference table), and a trailer (including `trailer`, `startxref`, and an EOF marker).
+
+```ruby
+require "jot_pdf"
+
+JotPDF::Core.write($stdout) do
+  header
+
+  # Emit your objects here
+
+  xref
+  trailer do
+  end
+end
+```
+
+Use `obj` to define an object; it returns a reference to the object.
+
+```ruby
+require "jot_pdf"
+
+JotPDF::Core.write($stdout) do
+  header
+
+  obj.of_dict do
+    entry("Type").of_name "Pages"
+    entry("Kids").of_array {}
+    entry("Count").of_int 0
+  end => pages_obj
+
+  obj.of_dict do
+    entry("Type").of_name "Catalog"
+    entry("Pages").of_ref pages_obj
+  end => catalog_obj
+
+  xref
+  trailer do
+     # JotPDF automatically inserts Size entry in the trailer dictionary
+    entry("Root").of_ref catalog_obj
+  end
+end
+```
+
+Use `alloc_obj` to declare an object and emit its contents later.
+
+```ruby
+require "jot_pdf"
+
+JotPDF::Core.write($stdout) do
+  header
+
+  alloc_obj => pages_obj
+
+  obj.of_dict do
+    entry("Type").of_name "Catalog"
+    entry("Pages").of_ref pages_obj
+  end => catalog_obj
+
+  obj(pages_obj).of_dict do
+    entry("Type").of_name "Pages"
+    entry("Kids").of_array {}
+    entry("Count").of_int 0
+  end
+
+  xref
+  trailer do
+    entry("Root").of_ref catalog_obj
+  end
+end
+```
+
+### JotPDF::Document
+
+Use `page` to emit a page.
+
+```ruby
+require "jot_pdf"
+
+JotPDF::Document.write($stdout) do
+  page width: 210, height: 297 do
+    text "Hello, World!", x: 10, y: 200
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/coord-e/jot_pdf. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/coord-e/jot_pdf/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the JotPDF project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/coord-e/jot_pdf/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+require "steep/rake_task"
+
+Steep::RakeTask.new do |t|
+  t.check.severity_level = :error
+  t.watch.verbose
+end
+
+task default: %i[steep spec rubocop]

data/Steepfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+  check "lib"
+  configure_code_diagnostics(D::Ruby.default)
+  # TODO: How to type instance variables inside the DSL?
+  # configure_code_diagnostics(D::Ruby.strict)
+end

data/lib/jot_pdf/core.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require "docile"
+
+module JotPDF
+  module Core
+    class CrossReferenceTableEntry < Data.define(:offset, :generation, :usage)
+    end
+
+    # separating definition for steep
+    class CrossReferenceTableEntry
+      def self.default
+        CrossReferenceTableEntry.new(
+          offset: 0,
+          generation: 65_535,
+          usage: :free,
+        )
+      end
+    end
+
+    class ObjectRef < Data.define(:number, :generation)
+    end
+
+    class Writer
+      attr_reader :objects, :io, :offset
+
+      def initialize(io)
+        @objects = [
+          CrossReferenceTableEntry.default,
+        ]
+        @section = [0]
+        @io = io
+        @offset = 0
+      end
+
+      def new_object
+        number = @objects.size
+        @objects << CrossReferenceTableEntry.default
+        ObjectRef.new(number:, generation: 0)
+      end
+
+      def update_object_entry(object_ref)
+        @section << object_ref.number
+        @objects[object_ref.number] = CrossReferenceTableEntry.new(
+          generation: object_ref.generation,
+          offset: @offset,
+          usage: :in_use,
+        )
+      end
+
+      def finish_section
+        result = @section.dup
+        @section.clear
+        result
+      end
+
+      def <<(data)
+        s = data.to_s
+        @io << s
+        @offset += s.bytesize
+        self
+      end
+    end
+
+    class WriteContext
+      def initialize(writer)
+        @writer = writer
+      end
+
+      def objects
+        @writer.objects
+      end
+
+      def dsl(&block)
+        Docile.dsl_eval(self, &block)
+      end
+    end
+
+    class DictionaryWriteContext < WriteContext
+      def entry(name, &block)
+        @writer << "/#{name}"
+        if block
+          ObjectWriteContext.new(@writer).dsl(&block)
+          @writer << "\n"
+        else
+          # TODO: Why does this need annotation?
+          # @type var finalizer: ^() -> ObjectRef
+          finalizer = proc { @writer << "\n" }
+          ObjectInterm.new(writer: @writer, finalizer:)
+        end
+      end
+    end
+
+    class ContentStreamWriteContext < WriteContext
+      def op(operator, &block)
+        ObjectWriteContext.new(@writer).dsl(&block) if block
+        @writer << " " << operator << "\n"
+      end
+    end
+
+    class ObjectWriteContext < WriteContext
+      def null
+        @writer << " null"
+      end
+
+      def bool(value)
+        @writer << " #{value}"
+      end
+
+      def name(name)
+        @writer << " /#{name}"
+      end
+
+      def num(value)
+        @writer << " " << value.to_s
+      end
+
+      def str(value)
+        @writer << " (" << value.to_s << ")"
+      end
+
+      def hexstr(value)
+        @writer << " <" << value.to_s << ">"
+      end
+
+      def ref(object_ref)
+        @writer << " #{object_ref.number} #{object_ref.generation} R"
+      end
+
+      def array(&block)
+        @writer << " ["
+        ObjectWriteContext.new(@writer).dsl(&block)
+        @writer << "]"
+      end
+
+      def dict(&block)
+        @writer << " <<\n"
+        DictionaryWriteContext.new(@writer).dsl(&block)
+        @writer << ">>"
+      end
+
+      def stream
+        @writer << "\nstream\n"
+        stream_start = @writer.offset
+        yield @writer
+        stream_size = @writer.offset - stream_start
+        @writer << "endstream"
+        stream_size
+      end
+
+      def content_stream(&block)
+        stream do |w|
+          ContentStreamWriteContext.new(w).dsl(&block)
+        end
+      end
+    end
+
+    class ObjectInterm
+      def initialize(writer:, finalizer:)
+        @writer = writer
+        @finalizer = finalizer
+      end
+
+      def of_null
+        @writer << " null"
+        @finalizer.call
+      end
+
+      def of_bool(value)
+        @writer << " #{value}"
+        @finalizer.call
+      end
+
+      def of_name(name)
+        @writer << " /#{name}"
+        @finalizer.call
+      end
+
+      def of_num(i)
+        @writer << " #{i}"
+        @finalizer.call
+      end
+
+      def of_str(value)
+        @writer << " (" << value.to_s << ")"
+        @finalizer.call
+      end
+
+      def of_hexstr(value)
+        @writer << " <" << value.to_s << ">"
+        @finalizer.call
+      end
+
+      def of_ref(object_ref)
+        @writer << " #{object_ref.number} #{object_ref.generation} R"
+        @finalizer.call
+      end
+
+      def of_dict(&block)
+        @writer << " <<\n"
+        DictionaryWriteContext.new(@writer).dsl(&block)
+        @writer << ">>"
+        @finalizer.call
+      end
+
+      def of_array(&block)
+        @writer << " ["
+        ObjectWriteContext.new(@writer).dsl(&block)
+        @writer << " ]"
+        @finalizer.call
+      end
+    end
+
+    class DocumentContext < WriteContext
+      def header(version = "1.4")
+        @writer << "%PDF-#{version}\n"
+        @writer << "%\xff\xff\xff\xff\n"
+      end
+
+      def alloc_obj
+        @writer.new_object
+      end
+
+      def obj(object_ref = nil, &block)
+        object_ref ||= @writer.new_object
+        @writer.update_object_entry(object_ref)
+        @writer << "#{object_ref.number} #{object_ref.generation} obj"
+        if block
+          ObjectWriteContext.new(@writer).dsl(&block)
+          @writer << "\nendobj\n"
+          object_ref
+        else
+          # TODO: Why does this need annotation?
+          # @type var finalizer: ^() -> ObjectRef
+          finalizer = proc { @writer << "\nendobj\n"; object_ref }
+          ObjectInterm.new(writer: @writer, finalizer:)
+        end
+      end
+
+      def xref
+        @prev_xref_offset = @xref_offset
+        @xref_offset = @writer.offset
+        @writer << "xref\n"
+        section_objs = @writer.finish_section
+        section_objs.sort.slice_when { |prev, curr| curr != prev.next }.each do |subsection|
+          @writer << "#{subsection.first} #{subsection.size}\n"
+          subsection.each do |n|
+            object = objects[n]
+            u = object.usage == :in_use ? "n" : "f"
+            # each entry ends with SP LF
+            @writer << "#{object.offset.to_s.rjust(10, "0")} #{object.generation.to_s.rjust(5, "0")} #{u} \n"
+          end
+        end
+      end
+
+      def trailer(&block)
+        @writer << "trailer\n<<\n"
+        DictionaryWriteContext.new(@writer).dsl do
+          entry("Size").of_num objects.size
+          entry("Prev").of_num @prev_xref_offset if @prev_xref_offset
+          dsl(&block)
+        end
+        @writer << ">>\n"
+
+        @writer << "startxref\n"
+        @writer << @xref_offset.to_s
+        @writer << "\n"
+
+        @writer << "%%EOF\n"
+      end
+
+      def dsl(&block)
+        Docile.dsl_eval(self, &block)
+      end
+    end
+
+    def self.write(io, &block)
+      Docile.dsl_eval(DocumentContext.new(Writer.new(io)), &block)
+    end
+  end
+end

data/lib/jot_pdf/document.rb

@@ -0,0 +1,508 @@
+# frozen_string_literal: true
+
+require "ttfunk"
+require "ttfunk/subset"
+
+module JotPDF
+  module Document
+    class StandardFont
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def unicode_to_code(codepoint)
+        raise if codepoint > 255
+
+        codepoint
+      end
+
+      def use(text)
+        text.each_codepoint.map { |c| format("%02x", unicode_to_code(c)) }.join
+      end
+    end
+
+    class NonstandardFont
+      attr_reader :subset
+
+      def initialize(font)
+        @subset = TTFunk::Subset.for(font, :unicode_8bit)
+      end
+
+      def name
+        @subset.original.name.postscript_name
+      end
+
+      def unicode_to_code(codepoint)
+        @subset.from_unicode(codepoint)
+      end
+
+      def use(text)
+        text.each_codepoint.map { |c| @subset.use(c); format("%02x", unicode_to_code(c)) }.join
+      end
+
+      def encode_subset
+        @subset.encode
+      end
+    end
+
+    class FontManager
+      attr_writer :default_font
+
+      def initialize(default_font:)
+        @fonts = {}
+        @default_font = default_font
+      end
+
+      def load_font(path)
+        font = TTFunk::File.open(path)
+        name = font.name.postscript_name
+        @fonts[name] = NonstandardFont.new(font)
+      end
+
+      def require(spec = nil)
+        spec ||= @default_font
+        if spec.is_a? Symbol
+          @fonts[spec] ||= StandardFont.new(spec)
+        else
+          @fonts.fetch(spec)
+        end
+      end
+
+      def loaded_fonts
+        @fonts
+      end
+    end
+
+    class PageContext
+      def initialize(ctx, font_manager:)
+        @ctx = ctx
+        @font_manager = font_manager
+      end
+
+      def color(color = nil, r: nil, g: nil, b: nil)
+        # rubocop:disable Style/RedundantCondition
+        r, g, b =
+          if color
+            colorspec(color)
+          else
+            colorspec(r:, g:, b:)
+          end
+        # rubocop:enable Style/RedundantCondition
+        @ctx.dsl do
+          op("rg") { num r; num g; num b }
+        end
+      end
+
+      def stroke_color(color = nil, r: nil, g: nil, b: nil)
+        # rubocop:disable Style/RedundantCondition
+        r, g, b =
+          if color
+            colorspec(color)
+          else
+            colorspec(r:, g:, b:)
+          end
+        # rubocop:enable Style/RedundantCondition
+        @ctx.dsl do
+          op("RG") { num r; num g; num b }
+        end
+      end
+
+      def stroke_width(width)
+        @ctx.dsl do
+          op("w") { num width }
+        end
+      end
+
+      def rect(x:, y:, width:, height:)
+        @ctx.dsl do
+          op("re") { num x; num y; num width; num height }
+        end
+      end
+
+      def path(*args)
+        @ctx.dsl do
+          x0, y0 = args.shift
+          op("m") { num x0; num y0 }
+          args.each do |x, y|
+            op("l") { num x; num y }
+          end
+          op("h")
+        end
+      end
+
+      def stroke
+        @ctx.dsl do
+          op("s")
+        end
+      end
+
+      def fill
+        @ctx.dsl do
+          op("f")
+        end
+      end
+
+      def text(text = nil, **kwargs, &block)
+        @ctx.dsl do
+          op("BT")
+          tc = TextContext.new(@ctx, font_manager: @font_manager, **kwargs)
+          tc.show text if text
+          tc.dsl(&block) if block
+          op("ET")
+        end
+      end
+
+      def image(n, x:, y:, width:, height:)
+        @ctx.dsl do
+          op("cm") { num width; num 0; num 0; num height; num x; num y }
+          op("Do") { name n }
+        end
+      end
+
+      def dsl(&block)
+        Docile.dsl_eval(self, &block)
+      end
+
+      private
+
+      def colorspec(color = nil, r: nil, g: nil, b: nil)
+        r ||= 0.0
+        g ||= 0.0
+        b ||= 0.0
+
+        if color
+          b = (color & 0xff).to_f
+          g = ((color >> 8) & 0xff).to_f
+          r = ((color >> 16) & 0xff).to_f
+        end
+
+        r /= 256.0 if r > 1
+        g /= 256.0 if g > 1
+        b /= 256.0 if b > 1
+
+        [r, g, b]
+      end
+    end
+
+    class TextContext < PageContext
+      undef_method :text
+
+      attr_reader :base_x, :base_y
+
+      def initialize(ctx, font_manager:, x: 0.0, y: 0.0, font: nil, size: nil, line_height: nil)
+        super(ctx, font_manager:)
+        @base_x = 0.0
+        @base_y = 0.0
+        move(x:, y:)
+        font(font, **{ size: }.compact)
+        @line_height = line_height
+      end
+
+      def font(spec, size: nil)
+        @font = @font_manager.require(spec)
+        size ||= @size
+        @size ||= size
+        @ctx.dsl do
+          op("Tf") { name @font.name; num(size || 15) }
+        end
+      end
+
+      def move(x:, y:)
+        @base_x += x
+        @base_y += y
+        @ctx.dsl do
+          op("Td") { num x; num y }
+        end
+      end
+
+      def linebreak(factor: 1.0)
+        # @type var factor: ::Numeric
+        move x: 0.0, y: -line_height * factor
+      end
+
+      def show(text)
+        @ctx.dsl do
+          text.each_line(chomp: true).with_index do |line, idx|
+            # @type self: JotPDF::Core::ContentStreamWriteContext & TextContext
+            move x: 0.0, y: -line_height unless idx.zero?
+            op("Tj") { hexstr @font.use(line) }
+          end
+        end
+      end
+
+      private
+
+      def line_height
+        @line_height || @size
+      end
+    end
+
+    class ImageContext
+      attr_reader :image_obj
+
+      def initialize(core, width:, height:)
+        @core = core
+        @width = width
+        @height = height
+        @mask_obj = core.alloc_obj
+        @image_obj = core.alloc_obj
+      end
+
+      def alpha(&block)
+        @core.dsl do
+          alloc_obj => length_obj
+          stream_size = nil
+          obj(@mask_obj) do
+            dict do
+              entry("Type").of_name "XObject"
+              entry("Subtype").of_name "Image"
+              entry("Width").of_num @width
+              entry("Height").of_num @height
+              entry("ColorSpace").of_name "DeviceGray"
+              entry("Decode").of_array { num 0; num 1 }
+              entry("BitsPerComponent").of_num 8
+              entry("Length").of_ref length_obj
+            end
+            stream(&block) => stream_size
+          end
+          obj(length_obj) { num stream_size }
+        end
+      end
+
+      def rgb(&block)
+        @core.dsl do
+          alloc_obj => length_obj
+          stream_size = nil
+          obj(@image_obj) do
+            dict do
+              entry("Type").of_name "XObject"
+              entry("Subtype").of_name "Image"
+              entry("Width").of_num @width
+              entry("Height").of_num @height
+              entry("ColorSpace").of_name "DeviceRGB"
+              entry("BitsPerComponent").of_num 8
+              entry("SMask").of_ref @mask_obj
+              entry("Length").of_ref length_obj
+            end
+            stream(&block) => stream_size
+          end
+          obj(length_obj) { num stream_size }
+        end
+      end
+
+      def dsl(&block)
+        Docile.dsl_eval(self, &block)
+      end
+    end
+
+    class DocumentWriter
+      attr_reader :pages, :images, :font_manager
+
+      def initialize(core, resources_obj:, pages_obj:)
+        @core = core
+        @pages = []
+        @pages_obj = pages_obj
+        @resources_obj = resources_obj
+        @images = {}
+        @font_manager = FontManager.new(default_font: :Helvetica)
+      end
+
+      def default_font(spec)
+        @font_manager.default_font = spec
+      end
+
+      def load_font(path)
+        @font_manager.load_font(path)
+      end
+
+      def image(n, width:, height:, &block)
+        ic = ImageContext.new(@core, width:, height:)
+        ic.dsl(&block)
+        @images[n] = ic.image_obj
+      end
+
+      def page(width:, height:, &block)
+        @core.dsl do
+          alloc_obj => length_obj
+
+          stream_size = nil
+          obj do
+            dict { entry("Length") { ref length_obj } }
+            content_stream do
+              PageContext.new(self, font_manager: @font_manager).dsl(&block)
+            end => stream_size
+          end => contents_obj
+
+          obj(length_obj) { num stream_size }
+
+          obj.of_dict do
+            entry("Type") { name "Page" }
+            entry("Parent") { ref @pages_obj }
+            entry("MediaBox").of_array { num 0; num 0; num width; num height }
+            entry("Resources") { ref @resources_obj }
+            entry("Contents") { ref contents_obj }
+          end => page_obj
+          @pages << page_obj
+        end
+      end
+
+      def dsl(&block)
+        Docile.dsl_eval(self, &block)
+      end
+    end
+
+    def self.generate_unicode_cmap(mapping)
+      <<~CMAP
+        /CIDInit /ProcSet findresource begin
+        12 dict begin
+        begincmap
+        /CIDSystemInfo 3 dict dup begin
+          /Registry (Adobe) def
+          /Ordering (UCS) def
+          /Supplement 0 def
+        end def
+        /CMapName /Adobe-Identity-UCS def
+        /CMapType 2 def
+
+        1 begincodespacerange
+        <00> <FF>
+        endcodespacerange
+
+        #{mapping.length} beginbfchar
+        #{mapping.map do |code, codepoint|
+            format("<%<code>02X><%<codepoint>s>", code:, codepoint: codepoint.chr(::Encoding::UTF_16BE).unpack1("H*"))
+          end.join("\n")}
+        endbfchar
+
+        endcmap
+        CMapName currentdict /CMap defineresource pop
+        end
+        end
+      CMAP
+    end
+
+    def self.write(io, &block)
+      Core.write(io) do
+        header
+
+        alloc_obj => resources_obj
+        alloc_obj => pages_obj
+        writer = Document::DocumentWriter.new(self, resources_obj:, pages_obj:)
+        writer.dsl(&block)
+
+        # @type var font_file_objs: Hash[::String | Symbol, ObjectRef]
+        # @type var widths_objs: Hash[::String | Symbol, ObjectRef]
+        # @type var tounicode_objs: Hash[::String | Symbol, ObjectRef]
+        font_file_objs = {}
+        widths_objs = {}
+        tounicode_objs = {}
+        writer.font_manager.loaded_fonts.each do |n, f|
+          # TODO: How can Steep use is_a? on _Font?
+          # rubocop:disable Style/CaseEquality
+          next unless NonstandardFont === f
+          # rubocop:enable Style/CaseEquality
+
+          subset_data = f.encode_subset
+          obj do
+            dict do
+              entry("Length").of_num subset_data.bytesize
+              entry("Length1").of_num subset_data.bytesize # always required for TrueType
+            end
+            stream do |stream|
+              stream << subset_data
+            end
+          end => font_file_obj
+          font_file_objs[n] = font_file_obj
+
+          subset = TTFunk::File.new(subset_data)
+          obj.of_array do
+            (subset.os2.first_char_index..subset.os2.last_char_index).each do |code|
+              gid = subset.cmap.tables.first[code]
+              width_in_units = subset.horizontal_metrics.for(gid).advance_width
+              num (Float(width_in_units) * 1000 / subset.header.units_per_em).to_i
+            end
+          end => widths_obj
+          widths_objs[n] = widths_obj
+
+          alloc_obj => length_obj
+          stream_size = nil
+          obj do
+            dict { entry("Length").of_ref length_obj }
+            stream do |w|
+              w << generate_unicode_cmap(f.subset.to_unicode_map)
+            end => stream_size
+          end => tounicode_obj
+          obj(length_obj).of_num stream_size
+          tounicode_objs[n] = tounicode_obj
+        end
+
+        obj(resources_obj).of_dict do
+          entry("XObject").of_dict do
+            writer.images.each do |n, r|
+              entry(n).of_ref r
+            end
+          end
+          entry("ProcSet").of_array { name "PDF"; name "Text"; name "ImageB"; name "ImageC"; name "ImageI" }
+          entry("Font").of_dict do
+            writer.font_manager.loaded_fonts.each do |n, f|
+              entry(n.to_s).of_dict do
+                entry("Type") { name "Font" }
+                case f
+                when StandardFont
+                  entry("Subtype") { name "Type1" }
+                  entry("BaseFont") { name n.to_s }
+                when NonstandardFont
+                  subset = TTFunk::File.new(f.encode_subset)
+                  # https://github.com/prawnpdf/prawn/blob/aaea7f6beda092ba48001414125a576dcf891362/lib/prawn/fonts/ttf.rb#L446-L447
+                  base_name = subset.name.postscript_name[0, 33].delete("\0")
+                  entry("Subtype").of_name "TrueType"
+                  entry("FirstChar").of_num subset.os2.first_char_index
+                  entry("LastChar").of_num subset.os2.last_char_index
+                  entry("ToUnicode").of_ref tounicode_objs[n]
+                  entry("BaseFont").of_name base_name
+                  entry("Widths").of_ref widths_objs[n]
+                  entry("FontDescriptor").of_dict do
+                    entry("Ascent").of_num subset.ascent
+                    entry("Descent").of_num subset.descent
+                    entry("CapHeight").of_num subset.os2.cap_height
+                    entry("StemV").of_num 0
+                    entry("ItalicAngle").of_num 0
+                    entry("Flags").of_num 0b100
+                    entry("FontBBox").of_array do
+                      subset.bbox.each do |i|
+                        num i
+                      end
+                    end
+                    entry("FontName").of_name base_name
+                    entry("XHeight").of_num subset.os2.x_height
+                    entry("FontFile2").of_ref font_file_objs[n]
+                  end
+                end
+              end
+            end
+          end
+        end => resources_obj
+
+        obj(pages_obj).of_dict do
+          entry("Type") { name "Pages" }
+          entry("Kids").of_array do
+            writer.pages.each do |page|
+              ref page
+            end
+          end
+          entry("Count") { num writer.pages.size }
+        end
+        obj.of_dict do
+          entry("Type") { name "Catalog" }
+          entry("Pages") { ref pages_obj }
+        end => root_obj
+        xref
+        trailer do
+          entry("Root") { ref root_obj }
+        end
+      end
+    end
+  end
+end

data/lib/jot_pdf/version.rb

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

data/lib/jot_pdf.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "jot_pdf/version"
+require_relative "jot_pdf/core"
+require_relative "jot_pdf/document"
+
+module JotPDF
+end

data/sig/jot_pdf/core.rbs

@@ -0,0 +1,96 @@
+module JotPDF
+  module Core
+    class CrossReferenceTableEntry
+      attr_reader offset: Integer
+      attr_reader generation: Integer
+      attr_reader usage: Symbol
+
+      def initialize: (offset: Integer, generation: Integer, usage: Symbol) -> void
+      def self.default: () -> CrossReferenceTableEntry
+    end
+
+    class ObjectRef
+      attr_reader number: Integer
+      attr_reader generation: Integer
+
+      def initialize: (number: Integer, generation: Integer) -> void
+    end
+
+    class Writer
+      @objects: Array[CrossReferenceTableEntry]
+      @io: IO
+      @offset: Integer
+      @section: Array[Integer]
+
+      attr_reader objects: Array[CrossReferenceTableEntry]
+      attr_reader io: IO
+      attr_reader offset: Integer
+
+      def initialize: (IO) -> void
+      def new_object: () -> ObjectRef
+      def update_object_entry: (ObjectRef) -> void
+      def finish_section: () -> Array[Integer]
+      def <<: (_ToS) -> self
+    end
+
+    class WriteContext
+      @writer: Writer
+
+      def initialize: (Writer) -> void
+      def objects: () -> Array[CrossReferenceTableEntry]
+      def dsl: [T] () { () [self: self] -> T } -> T
+    end
+
+    class DictionaryWriteContext < WriteContext
+      def entry: (_ToS) { () [self: ObjectWriteContext] -> untyped } -> void | (_ToS) -> ObjectInterm[void]
+    end
+
+    class ContentStreamWriteContext < WriteContext
+      def op: (_ToS) ?{ () [self: ObjectWriteContext] -> untyped } -> void
+    end
+
+    class ObjectWriteContext < WriteContext
+      def null: () -> void
+      def bool: (_ToS) -> void
+      def name: (_ToS) -> void
+      def num: (_ToS) -> void
+      def str: (_ToS) -> void
+      def hexstr: (_ToS) -> void
+      def ref: (ObjectRef) -> void
+      def array: () { () [self: ObjectWriteContext] -> untyped } -> void
+      def dict: () { () [self: DictionaryWriteContext] -> untyped } -> void
+      def stream: () { (Writer) -> untyped } -> Integer
+      def content_stream: () { () [self: ContentStreamWriteContext] -> untyped } -> Integer
+    end
+
+    class ObjectInterm[T]
+      @writer: Writer
+      @finalizer: ^() -> T
+
+      def initialize: (writer: Writer, finalizer: ^() -> T) -> void
+      def of_null: () -> T
+      def of_bool: (_ToS) -> T
+      def of_name: (_ToS) -> T
+      def of_num: (_ToS) -> T
+      def of_str: (_ToS) -> T
+      def of_hexstr: (_ToS) -> T
+      def of_ref: (ObjectRef) -> T
+      def of_dict: () { () [self: DictionaryWriteContext] -> untyped } -> T
+      def of_array: () { () [self: ObjectWriteContext] -> untyped } -> T
+    end
+
+    class DocumentContext < WriteContext
+      @prev_xref_offset: Integer?
+      @xref_offset: Integer?
+
+      def header: (?::String version) -> void
+      def alloc_obj: () -> ObjectRef
+      def obj: (?ObjectRef object_ref) { () [self: ObjectWriteContext] -> untyped } -> ObjectRef | (?ObjectRef object_ref) -> ObjectInterm[ObjectRef]
+      def xref: () -> void
+      def trailer: () { () [self: DictionaryWriteContext] -> untyped } -> void
+      def dsl: [T] () { () [self: self] -> T } -> T
+    end
+
+    def self.write: (IO) { () [self: DocumentContext] -> void } -> void
+  end
+end

data/sig/jot_pdf/document.rbs

@@ -0,0 +1,129 @@
+module JotPDF
+  module Document
+    interface _Font
+      def name: () -> (::String | ::Symbol)
+      def unicode_to_code: (::Integer) -> ::Integer
+      def use: (::String) -> ::String
+    end
+
+    class StandardFont
+      @name: ::Symbol
+      attr_reader name: ::Symbol
+
+      def initialize: (::Symbol) -> void
+      
+      def unicode_to_code: (::Integer) -> ::Integer
+      def use: (::String) -> ::String
+    end
+
+    class NonstandardFont
+      @subset: TTFunk::Subset
+      attr_reader subset: TTFunk::Subset
+
+      def initialize: (TTFunk::File) -> void
+
+      def name: () -> ::String
+      def unicode_to_code: (::Integer) -> ::Integer
+      def use: (::String) -> ::String
+
+      def encode_subset: () -> ::String
+    end
+
+    class FontManager
+      @fonts: Hash[::String | ::Symbol, _Font]
+      @default_font: ::String | ::Symbol
+      attr_writer default_font: ::String | ::Symbol
+
+      def initialize: (default_font: ::String | ::Symbol) -> void
+      def load_font: (::String) -> _Font
+      def require: (?(::String | ::Symbol | nil)) -> _Font
+      def loaded_fonts: () -> Hash[::String | ::Symbol, _Font]
+    end
+
+    class PageContext
+      @ctx: JotPDF::Core::ContentStreamWriteContext
+      @font_manager: FontManager
+
+      def initialize: (JotPDF::Core::ContentStreamWriteContext, font_manager: FontManager) -> void
+      def color: (::Integer) -> void | (r: ::Float, g: ::Float, b: ::Float) -> void
+      def stroke_color: (::Integer) -> void | (r: ::Float, g: ::Float, b: ::Float) -> void
+      def stroke_width: (::Float) -> void
+      def rect: (x: ::Float, y: ::Float, width: ::Float, height: ::Float) -> void
+      def path: (*[::Float, ::Float]) -> void
+      def stroke: () -> void
+      def fill: () -> void
+      def text: (?::String?, ?x: ::Float, ?y: ::Float, ?font: ::String | ::Symbol, ?size: ::Float, ?line_height: ::Float) ?{ () [self: TextContext] -> void } -> void
+      def image: (::String, x: ::Float, y: ::Float, width: ::Float, height: ::Float) -> void
+
+      def dsl: [T] () { () [self: self] -> T } -> T
+
+      private
+
+      def colorspec: (::Integer) -> [::Float, ::Float, ::Float] | (r: ::Float?, g: ::Float?, b: ::Float?) -> [::Float, ::Float, ::Float]
+    end
+
+    class TextContext < PageContext
+      @base_x: ::Float
+      @base_y: ::Float
+      @line_height: ::Float?
+      @font: _Font
+      @size: ::Float
+      attr_reader base_x: ::Float
+      attr_reader base_y: ::Float
+
+      def initialize: (JotPDF::Core::ContentStreamWriteContext, font_manager: FontManager, ?x: ::Float, ?y: ::Float, ?font: ::String?, ?size: ::Float?, ?line_height: ::Float?) -> void
+
+      def font: (::String | ::Symbol | nil, ?size: ::Float | nil) -> void
+      def move: (x: ::Float, y: ::Float) -> void
+      def linebreak: (?factor: ::Float) -> void
+      def show: (::String) -> void
+
+      private
+
+      def line_height: () -> (::Float)
+    end
+
+    class ImageContext
+      @core: JotPDF::Core::DocumentContext
+      @width: ::Float
+      @height: ::Float
+      @mask_obj: JotPDF::Core::ObjectRef
+      @image_obj: JotPDF::Core::ObjectRef
+
+      attr_reader image_obj: JotPDF::Core::ObjectRef
+
+      def initialize: (JotPDF::Core::DocumentContext, width: ::Float, height: ::Float) -> void
+
+      def alpha: () { (JotPDF::Core::Writer) -> void } -> void
+      def rgb: () { (JotPDF::Core::Writer) -> void } -> void
+
+      def dsl: [T] () { () [self: self] -> T } -> T
+    end
+
+    class DocumentWriter
+      @core: JotPDF::Core::DocumentContext
+      @pages: Array[JotPDF::Core::ObjectRef]
+      @pages_obj: JotPDF::Core::ObjectRef
+      @resources_obj: JotPDF::Core::ObjectRef
+      @images: Hash[::String, JotPDF::Core::ObjectRef]
+      @font_manager: FontManager  
+
+      attr_reader pages: Array[JotPDF::Core::ObjectRef]
+      attr_reader images: Hash[::String, JotPDF::Core::ObjectRef]
+      attr_reader font_manager: FontManager
+
+      def initialize: (JotPDF::Core::DocumentContext, resources_obj: JotPDF::Core::ObjectRef, pages_obj: JotPDF::Core::ObjectRef  ) -> void
+
+      def default_font: (::String | ::Symbol) -> void  
+      def load_font: (::String) -> void
+      def image: (::String, width: ::Float, height: ::Float) { () [self: ImageContext] -> void } -> void  
+      def page: (width: ::Float, height: ::Float) { () [self: PageContext] -> void } -> void
+
+      def dsl: [T] () { () [self: DocumentWriter] -> T } -> T
+    end
+
+    def self.generate_unicode_cmap: (Hash[::Integer, ::Integer]) -> ::String
+
+    def self.write: (IO) { () [self: DocumentWriter] -> void } -> void
+  end
+end

data/sig/jot_pdf.rbs

@@ -0,0 +1,3 @@
+module JotPDF
+  VERSION: String
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: jot_pdf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- coord_e
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2025-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: ttfunk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email:
+- me@coord-e.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- lib/jot_pdf.rb
+- lib/jot_pdf/core.rb
+- lib/jot_pdf/document.rb
+- lib/jot_pdf/version.rb
+- sig/jot_pdf.rbs
+- sig/jot_pdf/core.rbs
+- sig/jot_pdf/document.rbs
+homepage: https://github.com/coord-e/jot_pdf
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/coord-e/jot_pdf
+  source_code_uri: https://github.com/coord-e/jot_pdf
+  changelog_uri: https://github.com/coord-e/jot_pdf/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key: 
+specification_version: 4
+summary: Streaming PDF writer DSL
+test_files: []