stationery 0.8.0 → 0.9.0

data/lib/stationery/tagging/element.rb

@@ -39,7 +39,7 @@ module Stationery
         @type = type
         @alt = alt
         @kind = kind
-        @attributes = attributes.transform_values(&:dup)
+        @attributes = attributes.empty? ? {} : attributes.transform_values(&:dup)
         @kids = []
       end
 

data/lib/stationery/testing/inspector.rb

@@ -133,6 +133,19 @@ module Stationery
         entries.each_slice(2).map { |_name, ref| attachment(objects.deref_hash(ref)) }
       end
 
+      # Every signed signature field: `{ field:, name:, reason:, location:,
+      # signed_at:, subfilter:, byte_range:, signer:, valid: }`. `signer` is
+      # the signing certificate's subject ("CN=…,O=…"). `valid` is whether
+      # the signature covers the whole file and verifies against the
+      # certificate it carries; the certificate's own trust is not judged.
+      def signatures
+        form = catalog[:AcroForm]
+        return [] unless form
+
+        require "openssl"
+        signature_fields(objects.deref_hash(form)[:Fields], nil)
+      end
+
       # The structure tree of a tagged PDF as nested arrays; see StructureReader.
       def structure = @structure ||= StructureReader.new(reader).tree
 
@@ -167,6 +180,48 @@ module Stationery
           description: spec[:Desc] && decode(spec[:Desc]), relationship: }
       end
 
+      def signature_fields(refs, prefix)
+        Array(objects.deref_array(refs)).flat_map do |ref|
+          field = objects.deref_hash(ref)
+          name = [prefix, field[:T] && decode(field[:T])].compact.join(".")
+          kids = Array(objects.deref_array(field[:Kids])).select { |kid| objects.deref_hash(kid).key?(:T) }
+          next signature_fields(kids, name) if kids.any?
+
+          field[:FT] == :Sig && field[:V] ? [signature(name, objects.deref_hash(field[:V]))] : []
+        end
+      end
+
+      def signature(field, value)
+        range = objects.deref_array(value[:ByteRange])
+        text = value.slice(:Name, :Reason, :Location).transform_values { |string| decode(string) }
+        { field:, name: text[:Name], reason: text[:Reason], location: text[:Location],
+          signed_at: signing_time(value[:M]), subfilter: value[:SubFilter], byte_range: range, **verdict(range) }
+      end
+
+      def signing_time(date)
+        digits = date.to_s[/\AD:(\d{14})/, 1]
+        digits && Time.utc(*digits.unpack("a4a2a2a2a2a2").map(&:to_i))
+      end
+
+      # The signature is read from the file by its byte range, not from the
+      # parsed dictionary: it is the one string encryption leaves alone.
+      def verdict(range)
+        contents = pdf.byteslice(range[1], range[2] - range[1]).to_s
+        cms = OpenSSL::PKCS7.new(PDF::Signature.der([contents[1..-2]].pack("H*")))
+        signed = pdf.byteslice(range[0], range[1]) + pdf.byteslice(range[2], range[3])
+        flags = OpenSSL::PKCS7::NOVERIFY | OpenSSL::PKCS7::BINARY
+        whole = range[0].zero? && range[2] + range[3] == pdf.bytesize && contents.start_with?("<")
+        { signer: signer(cms), valid: whole && cms.verify([], OpenSSL::X509::Store.new, signed, flags) }
+      rescue OpenSSL::OpenSSLError, ArgumentError, TypeError
+        { signer: nil, valid: false }
+      end
+
+      def signer(cms)
+        info = cms.signers.first
+        certificate = cms.certificates.find { |one| one.serial == info.serial && one.issuer == info.issuer }
+        certificate&.subject&.to_utf8
+      end
+
       def xmp_value(body)
         items = body.scan(XMP_ITEM).flatten.map { |item| xmp_text(item) }
         return xmp_text(body) if items.empty?

data/lib/stationery/testing/matchers.rb

@@ -183,6 +183,30 @@ module Stationery
         end
       end
 
+      class HaveSignature < Base
+        def initialize(name: nil, valid: true)
+          super(name)
+          @valid = valid
+        end
+
+        def description
+          "have #{@valid ? "a valid" : "an invalid"} signature#{" by #{show(@expected)}" if @expected}"
+        end
+
+        private
+
+        def match?(pdf)
+          pdf.signatures.any? { |one| (@expected.nil? || one[:name] == @expected) && one[:valid] == @valid }
+        end
+
+        def actual
+          signatures = @inspector.signatures
+          return "got none" if signatures.empty?
+
+          "got #{signatures.map { |one| "#{one[:name].inspect} (#{one[:valid] ? "valid" : "invalid"})" }.join(", ")}"
+        end
+      end
+
       class HaveNoWarnings < Base
         def description = "have no warnings"
 
@@ -227,6 +251,7 @@ module Stationery
       def have_attachment(name, **) = HaveAttachment.new(name, **)
       def have_conformance(*levels) = HaveConformance.new(*levels)
       def have_factur_x(profile: nil) = HaveFacturX.new(profile:)
+      def have_signature(name: nil, valid: true) = HaveSignature.new(name:, valid:)
       def have_no_warnings = HaveNoWarnings.new
       def have_structure(expected) = HaveStructure.new(expected)
       def have_tagged_content = HaveTaggedContent.new

data/lib/stationery/text/wrapper.rb

@@ -26,6 +26,7 @@ module Stationery
         @current = []
         @pending_space = []
         @fallback = fallback_style
+        @widths = {}.compare_by_identity
         items(runs).each { |item| place(item) }
         finish unless @current.empty? && @lines.any? && !@ended_with_newline
         @lines
@@ -97,6 +98,8 @@ module Stationery
       # its hyphen) fits `available`; nil when the word offers no break that
       # fits. Soft hyphens name the breaks and suppress the patterns.
       def hyphenated(word, available)
+        return unless @explicit || word.first&.style&.hyphenate
+
         chars = word.flat_map { |segment| segment.text.chars.map { |char| Segment.new(char, segment.style) } }
         break_points(chars).reverse_each do |index|
           head = chars.first(index).reject { |segment| segment.text == SOFT_HYPHEN }
@@ -164,7 +167,7 @@ module Stationery
       def fragments(segments)
         x = 0
         segments.chunk_while { |a, b| a.style == b.style }.filter_map do |group|
-          text = group.map(&:text).join.delete(SOFT_HYPHEN)
+          text = plain(group.map(&:text).join)
           next if text.empty?
 
           font, face = @book.resolve(group.first.style)
@@ -178,12 +181,18 @@ module Stationery
       end
 
       def line_width = width(@current)
-      def characters(segments) = segments.sum { |segment| segment.text.delete(SOFT_HYPHEN).length }
+      def characters(segments) = segments.sum { |segment| plain(segment.text).length }
 
+      # A line is summed again for every word that joins it; its segments
+      # are the same objects each time, so each is measured once per wrap.
       def width(segments)
-        segments.sum { |segment| measure(segment.text.delete(SOFT_HYPHEN), segment.style) }
+        segments.sum { |segment| @widths[segment] ||= measure(plain(segment.text), segment.style) }
       end
 
+      # The text without its soft hyphens; the same String when it has none,
+      # which is nearly always, so measuring a word allocates nothing.
+      def plain(text) = text.include?(SOFT_HYPHEN) ? text.delete(SOFT_HYPHEN) : text
+
       def measure(text, style)
         font = @book.resolve(style).first
         font.width_of(text, style.render_size, letter_spacing: style.letter_spacing, kerning: style.kerning,

data/lib/stationery/version.rb

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

data/lib/stationery/warnings.rb

@@ -43,6 +43,10 @@ module Stationery
       def message = %(link "#{href}" dropped: scheme not allowed)
     end
 
+    NestingLimit = Data.define(:depth, :limit) do
+      def message = "content nested #{depth} levels deep was flattened below level #{limit}"
+    end
+
     DuplicateAnchor = Data.define(:name, :page) do
       def message = %(anchor "#{name}" on page #{page} is already defined)
     end

data/lib/stationery.rb

@@ -66,7 +66,10 @@ require_relative "stationery/pdf/attachments"
 require_relative "stationery/pdf/xmp"
 require_relative "stationery/pdf/conformance"
 require_relative "stationery/pdf/factur_x"
+require_relative "stationery/pdf/signature"
+require_relative "stationery/pdf/signature/cms"
 require_relative "stationery/forms/metrics"
+require_relative "stationery/forms/typeface"
 require_relative "stationery/forms/field"
 require_relative "stationery/forms/appearance"
 require_relative "stationery/forms/acro_form"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stationery
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -88,6 +88,7 @@ files:
 - lib/stationery/forms/appearance.rb
 - lib/stationery/forms/field.rb
 - lib/stationery/forms/metrics.rb
+- lib/stationery/forms/typeface.rb
 - lib/stationery/geometry.rb
 - lib/stationery/html/document.rb
 - lib/stationery/html/tokenizer.rb
@@ -158,6 +159,8 @@ files:
 - lib/stationery/pdf/outline_writer.rb
 - lib/stationery/pdf/page_labels.rb
 - lib/stationery/pdf/serializer.rb
+- lib/stationery/pdf/signature.rb
+- lib/stationery/pdf/signature/cms.rb
 - lib/stationery/pdf/stream.rb
 - lib/stationery/pdf/types.rb
 - lib/stationery/pdf/writer.rb
@@ -168,8 +171,10 @@ files:
 - lib/stationery/railtie.rb
 - lib/stationery/regions.rb
 - lib/stationery/resources.rb
+- lib/stationery/rich/nesting.rb
 - lib/stationery/rich/nodes.rb
 - lib/stationery/rich/renderer.rb
+- lib/stationery/rich/renderer/indents.rb
 - lib/stationery/rich/renderer/inlines.rb
 - lib/stationery/rich/renderer/links.rb
 - lib/stationery/rich/styles.rb