carve-hexapdf 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e542a29c024a850009d9f9fa32d6fe69ba870a97eab23f595522878d7da1c367
-  data.tar.gz: 05d84eaa30d5ad7c4d6f111dc442f88a113bf8a7aa817849df4ee7b58bb5942f
+  metadata.gz: 998af42c6a5a9753c0874cbdd003da94d3433303de6051f1a784a7beb3f3d2a1
+  data.tar.gz: dfe6a046b7e1026ebe8c9ce6c1364872d58f9e407441049cba2a7dd9c63fce66
 SHA512:
-  metadata.gz: 1382a76d094f651b2cc1b6cbae0ce65409d27222e02f4355361fce93ef6c9cc873b1ebd58ea01b6f02003ebb112ee8228784bb4dddf0aea60ac7186fc4e48f74
-  data.tar.gz: 25cd7967c9fe80a6c18df8a2d261c6d27d041a874029c056b52f43f621af5e97f939e3a19f9c141eaa51a87292829445ac58b8074a09a477c8afd61cff31b149
+  metadata.gz: c9a88ff35c2faaa48db5a26344b49837d53b00212db3bd9f3ba44a743d32a212c16cbabe1b8fe7c2a0469882a93c7bd3684faaeddf91c3329af371440783c7de
+  data.tar.gz: 203abfd74c94db24dc267e14c8ab93dce5acc49e6ff98312fa17fb0c211b40f4c87dea3eafd62f9e9c8b78e06cf2025ae8f38a9a01ad849a072eac5aa3deef32

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.7] - 2026-11-12
+
+The default fonts no longer crash the render: `x <= 10` and CJK text now produce a PDF.
+
+### Fixes
+
+- Text the font cannot draw no longer aborts the render. With the default Type1 fonts, `<=`, `>=` and `!=` print as written instead of `≤ ≥ ≠`, and other characters without a glyph print as `?` with a warning; a TrueType `base_font:` draws them (#70, #71).
+
+**Full Changelog**: https://github.com/markup-carve/carve-hexapdf/compare/v0.1.6...v0.1.7
+
 ## [0.1.6] - 2026-11-12
 
 Definition lists and table cell alignment now reach the PDF, the gem loads on Ruby 3.4, and the engine moves to carve-lang 0.1.14.

data/lib/carve/hexapdf/renderer.rb

@@ -61,6 +61,8 @@ module Carve
                                            highlight_color: highlight_color,
                                            styles: styles))
         @renderers = renderers || {}
+        @drawable = {}
+        @warned = {}
       end
 
       def render_document(doc)
@@ -186,7 +188,7 @@ module Carve
         content = resolve_nbsp(node[:content]).chomp
         style = style_for("code.block", inherited_font: true, with_box: true)
         box = style.delete(:box)
-        target.text(content, **style, box_style: box)
+        target.text(drawable_text(content, style[:font] || code_font), **style, box_style: box)
       end
 
       def list(node, target)
@@ -386,7 +388,8 @@ module Carve
         else
           alt = resolve_nbsp(node[:alt])
           alt = "[image: #{node[:src]}]" if alt.empty?
-          target.formatted_text([{ text: alt, font: [base_font, { variant: :italic }] }],
+          font = [base_font, { variant: :italic }]
+          target.formatted_text([{ text: drawable_text(alt, font), font: font }],
                                 margin: [0, 0, BLOCK_GAP])
         end
       end
@@ -399,7 +402,8 @@ module Carve
         style = style_for("math", with_box: true)
         box = style.delete(:box)
         style[:font] ||= code_font
-        target.text(node[:content].to_s, **style, text_align: :center, box_style: box)
+        target.text(drawable_text(node[:content].to_s, style[:font]), **style,
+                    text_align: :center, box_style: box)
       end
 
       def thematic_break(target)
@@ -649,7 +653,8 @@ module Carve
             Array(pair[:annotation]).each { |part| emit_inline(part, ctx, out) }
             out << run(")", ctx)
           end
-        when "smart_punctuation" then out << run(smart_punctuation_text(node), ctx)
+        when "smart_punctuation"
+          out << run(smart_punctuation_text(node), ctx, fallback: node[:value])
         # A character the author escaped. The backslash is authoring syntax, so
         # the page shows the character - but the node has no children, so
         # without this arm it falls through to the branch that emits children
@@ -767,7 +772,9 @@ module Carve
         text.to_s.gsub(RESOLVED_NBSP, NBSP)
       end
 
-      def run(text, ctx)
+      # +fallback+ is the author's spelling of the same text, drawn instead when
+      # the run font cannot draw +text+ (a smart-typography glyph).
+      def run(text, ctx, fallback: nil)
         item = { text: resolve_nbsp(text) }
         if ctx[:code]
           # :box is a block-level pseudo-property (e.g. inherited from a user
@@ -793,9 +800,77 @@ module Carve
           item[:link] = ctx[:link]
           item.merge!(run_style("link"))
         end
+        font = item[:font] || ctx[:font_family] || base_font
+        item[:text] = drawable_text(item[:text], font, fallback: fallback)
         item
       end
 
+      # A character the font cannot encode raises inside HexaPDF and loses the
+      # whole document (carve-hexapdf#70). That is either a missing glyph (CJK
+      # in Times) or a glyph the font's encoding cannot reach (standard Type1
+      # Times has `lessequal`, WinAnsi has no slot for it).
+      def drawable_text(text, font, fallback: nil)
+        wrapper = font_wrapper(font)
+        return text if wrapper.nil? || text.each_char.all? { |ch| drawable?(wrapper, ch) }
+
+        if fallback && fallback.to_s.each_char.all? { |ch| drawable?(wrapper, ch) }
+          return fallback.to_s
+        end
+
+        text.each_char.map do |ch|
+          next ch if drawable?(wrapper, ch)
+
+          warn_missing_glyph(wrapper, ch)
+          drawable?(wrapper, REPLACEMENT) ? REPLACEMENT : ""
+        end.join
+      end
+
+      REPLACEMENT = "?"
+
+      def font_wrapper(font)
+        return font if font.respond_to?(:decode_codepoint)
+
+        name, opts = font.is_a?(Array) ? font : [font, {}]
+        return name if name.respond_to?(:decode_codepoint)
+
+        document = @c.document
+        name ||= document.config["font.default"]
+        document.fonts.add(name, variant: (opts || {})[:variant] || :none)
+      rescue StandardError
+        nil
+      end
+
+      # Mirrors HexaPDF: decode, let `font.on_invalid_glyph` (and so any
+      # configured `font.fallback`) supply a missing glyph, then encode. Tabs,
+      # line breaks and the like are layout controls, never drawn.
+      def drawable?(wrapper, char)
+        key = [wrapper, char]
+        return @drawable[key] if @drawable.key?(key)
+
+        @drawable[key] = encodable?(wrapper, char)
+      end
+
+      def encodable?(wrapper, char)
+        glyphs = [wrapper.decode_codepoint(char.ord)]
+        if glyphs.first.is_a?(::HexaPDF::Font::InvalidGlyph)
+          return true if glyphs.first.control_char?
+
+          glyphs = @c.document.config["font.on_invalid_glyph"].call(char.ord, glyphs.first)
+        end
+        glyphs.all? { |g| !g.is_a?(::HexaPDF::Font::InvalidGlyph) && g.font_wrapper.encode(g) }
+      rescue ::HexaPDF::Error
+        false
+      end
+
+      def warn_missing_glyph(wrapper, char)
+        return if @warned[[wrapper, char]]
+
+        @warned[[wrapper, char]] = true
+        name = wrapper.wrapped_font.full_name rescue wrapper.to_s
+        warn format("carve-hexapdf: font '%s' has no glyph for U+%04X %p; drawing %p instead",
+                    name, char.ord, char, REPLACEMENT)
+      end
+
       # Link/highlight styles are decoration overlays on a run that may already
       # carry a variant or code font; the font they inherit from +base+ must not
       # clobber it (only a font set explicitly on the key itself wins), and a

data/lib/carve/hexapdf/version.rb

@@ -2,6 +2,6 @@
 
 module Carve
   module Hexapdf
-    VERSION = "0.1.6"
+    VERSION = "0.1.7"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carve-hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - markup-carve