pdfrb 0.3.0 → 0.7.1

data/lib/pdfrb/content/smart_text_extractor.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module SmartTextExtractor
+      module_function
+
+      def extract(document)
+        results = []
+        document.pages.each do |page|
+          text = extract_page_text(document, page)
+          results << { page: page, text: text }
+        end
+
+        block_given? ? yield(results) : results
+      end
+
+      def extract_page_text(document, page)
+        contents = page.value[:Contents]
+        return "" unless contents
+
+        ref = contents.is_a?(Pdfrb::Model::Reference) ? contents : nil
+        return "" unless ref
+
+        stream = document.object(ref)
+        return "" unless stream.is_a?(Pdfrb::Model::Cos::Stream)
+
+        data = stream.decoded_stream
+        return "" unless data && !data.empty?
+
+        collector = TextCollector.new(document, page)
+        begin
+          collector.process(data)
+        rescue StandardError
+          # Best effort extraction
+        end
+        collector.text
+      end
+
+      class TextCollector < Pdfrb::Content::Processor
+        attr_reader :text
+
+        def initialize(document, page)
+          super()
+          @document = document
+          @page = page
+          @text = +""
+          @last_y = nil
+        end
+
+        def show_text(str)
+          insert_line_break_if_needed
+          @text << decode_text(str)
+        end
+
+        def show_text_array(arr)
+          insert_line_break_if_needed
+          arr.each do |e|
+            @text << decode_text(e) if e.is_a?(String)
+          end
+        end
+
+        def move_text(tx, ty, **)
+          super
+          insert_line_break_if_needed
+        end
+
+        private
+
+        def insert_line_break_if_needed
+          cur_y = graphics_state.text_state.text_matrix.f
+          if @last_y && (cur_y - @last_y).abs > 0.001
+            @text << "\n"
+          end
+          @last_y = cur_y
+        end
+
+        def decode_text(bytes)
+          bytes.to_s.dup.force_encoding("UTF-8")
+        end
+      end
+      private_constant :TextCollector
+    end
+  end
+end

data/lib/pdfrb/content/tiling_pattern.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    # Tiling patterns (ISO 32000-2 §8.7.3). A tiling pattern is a
+    # repeating cell that fills an area. Type 1 (constant spacing) and
+    # Type 2 (no distortion) are supported.
+    #
+    # The pattern cell is drawn via a block using the Canvas API.
+    # Registered in page Resources under /Pattern.
+    class TilingPattern
+      PATTERN_TYPE = 1
+
+      attr_reader :paint_type, :tiling_type, :bbox, :x_step, :y_step
+
+      # @param paint_type [Integer] 1 = colored, 2 = uncolored.
+      # @param tiling_type [Integer] 1 = constant, 2 = no distortion, 3 = constant spacing + no distortion.
+      # @param bbox [Array] bounding box of the pattern cell.
+      # @param x_step [Numeric] horizontal repeat distance.
+      # @param y_step [Numeric] vertical repeat distance.
+      def initialize(paint_type: 1, tiling_type: 1, bbox: [0, 0, 16, 16],
+                     x_step: 16, y_step: 16)
+        @paint_type = paint_type
+        @tiling_type = tiling_type
+        @bbox = bbox
+        @x_step = x_step
+        @y_step = y_step
+      end
+
+      # Build the pattern stream and register it in the page's Resources.
+      # @param document [Pdfrb::Document]
+      # @param page [Pdfrb::Model::Cos::Dictionary] target page.
+      # @yield [canvas] block that draws the pattern cell.
+      # @return [Symbol] the resource name (e.g. :P1)
+      def register_on(document, page)
+        pattern_stream = document.add(
+          {
+            Type: :Pattern,
+            PatternType: PATTERN_TYPE,
+            PaintType: @paint_type,
+            TilingType: @tiling_type,
+            BBox: @bbox,
+            XStep: @x_step,
+            YStep: @y_step,
+          },
+          type: Pdfrb::Model::Cos::Stream
+        )
+
+        if block_given?
+          canvas = Pdfrb::Content::Canvas.new(pattern_stream, document: document)
+          yield canvas
+        end
+
+        ref = Pdfrb::Model::Reference.new(pattern_stream.oid, pattern_stream.gen)
+        register_in_resources(document, page, ref)
+      end
+
+      private
+
+      def register_in_resources(_document, page, ref)
+        resources = page.value[:Resources]
+        resources = {} unless resources.is_a?(::Hash)
+        pattern_dict = resources[:Pattern] || {}
+        name = next_pattern_name(pattern_dict)
+        pattern_dict[name] = ref
+        resources[:Pattern] = pattern_dict
+        page.value[:Resources] = resources
+        name
+      end
+
+      def next_pattern_name(pattern_dict)
+        existing = pattern_dict.keys.map(&:to_s).grep(/\AP\d+\z/).map { |k| k[1..].to_i }
+        num = (existing.max || 0) + 1
+        :"P#{num}"
+      end
+    end
+  end
+end

data/lib/pdfrb/content/transformation_matrix.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    class TransformationMatrix
+      attr_reader :a, :b, :c, :d, :e, :f
+
+      def initialize(a = 1, b = 0, c = 0, d = 1, e = 0, f = 0)
+        @a = a.to_f
+        @b = b.to_f
+        @c = c.to_f
+        @d = d.to_f
+        @e = e.to_f
+        @f = f.to_f
+        freeze
+      end
+
+      def identity?
+        @a == 1 && @b.zero? && @c.zero? && @d == 1 && @e.zero? && @f.zero?
+      end
+
+      def multiply(other)
+        self.class.new(
+          (@a * other.a) + (@c * other.b),
+          (@b * other.a) + (@d * other.b),
+          (@a * other.c) + (@c * other.d),
+          (@b * other.c) + (@d * other.d),
+          (@a * other.e) + (@c * other.f) + @e,
+          (@b * other.e) + (@d * other.f) + @f,
+        )
+      end
+
+      def translate(tx, ty)
+        multiply(self.class.new(1, 0, 0, 1, tx, ty))
+      end
+
+      def scale(sx, sy = sx)
+        multiply(self.class.new(sx, 0, 0, sy, 0, 0))
+      end
+
+      def rotate(angle_radians)
+        cos = Math.cos(angle_radians)
+        sin = Math.sin(angle_radians)
+        multiply(self.class.new(cos, sin, -sin, cos, 0, 0))
+      end
+
+      def skew(fa, fb)
+        multiply(self.class.new(1, Math.tan(fa), Math.tan(fb), 1, 0, 0))
+      end
+
+      def to_a
+        [@a, @b, @c, @d, @e, @f]
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && to_a == other.to_a
+      end
+      alias eql? ==
+    end
+  end
+end

data/lib/pdfrb/content.rb

@@ -1,38 +1,19 @@
 # frozen_string_literal: true
 
 module Pdfrb
-  # Content-stream layer. Pages and Form XObjects carry a content
-  # stream: a sequence of `operands operator` instructions that draw
-  # graphics and text. This layer parses, walks, and emits those
-  # streams.
-  #
-  # Architecture mirrors HexaPDF::Content:
-  #   * +Tokenizer+ from Source layer produces tokens (content
-  #     streams use the same PDF object syntax as COS values).
-  #   * +Content::Parser+ groups operands + operator into invocations.
-  #   * +Content::Operator::Base+ subclasses implement each PDF
-  #     operator (one file per category — open/closed via `register`).
-  #   * +Content::Processor+ walks a stream, invoking operators
-  #     against a +GraphicsState+ (with a stack for `q`/`Q`).
-  #   * +Content::Canvas+ is the high-level drawing API on a Stream.
   module Content
     autoload :GraphicsState, "pdfrb/content/graphics_state"
     autoload :Operator, "pdfrb/content/operator"
     autoload :Parser, "pdfrb/content/parser"
     autoload :Processor, "pdfrb/content/processor"
+    autoload :ColorSpace, "pdfrb/content/color_space"
+    autoload :TransformationMatrix, "pdfrb/content/transformation_matrix"
     autoload :Canvas, "pdfrb/content/canvas"
     autoload :GraphicObject, "pdfrb/content/graphic_object"
+    autoload :Operators, "pdfrb/content/operators"
+    autoload :TilingPattern, "pdfrb/content/tiling_pattern"
+    autoload :HiddenTextDetector, "pdfrb/content/hidden_text_detector"
+    autoload :SmartTextExtractor, "pdfrb/content/smart_text_extractor"
+    autoload :Shading, "pdfrb/content/shading"
   end
 end
-
-# Eager-load operator subclasses so they self-register in the
-# Operator::REGISTRY. (Each file calls Operator.register at the bottom.)
-require "pdfrb/content/operators/general"
-require "pdfrb/content/operators/path"
-require "pdfrb/content/operators/painting"
-require "pdfrb/content/operators/text_state"
-require "pdfrb/content/operators/text_positioning"
-require "pdfrb/content/operators/text_showing"
-require "pdfrb/content/operators/color"
-require "pdfrb/content/operators/graphics_state_params"
-require "pdfrb/content/operators/marked_content"

data/lib/pdfrb/destination/fit.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Destination
+    # Destination fit types (ISO 32000-2 §12.3.2.2). Each type specifies
+    # how the page should be displayed when navigated to.
+    #
+    # OCP: new fit type = subclass + register_as.
+    class Fit
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(name, klass)
+          registry[name.to_sym] = klass
+        end
+
+        def [](name)
+          registry[name.to_sym]
+        end
+
+        def types
+          registry.keys
+        end
+
+        def fit_keyword
+          raise NotImplementedError
+        end
+
+        def register_as(name = fit_keyword)
+          Fit.register(name, self)
+          self
+        end
+      end
+
+      attr_reader :page_ref
+
+      def initialize(page_ref)
+        @page_ref = page_ref
+      end
+
+      # Serialize to the PDF destination array form.
+      # @return [Pdfrb::Model::PdfArray]
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, self.class.fit_keyword])
+      end
+    end
+
+    # /Fit — fit the entire page in the window.
+    class FullPage < Fit
+      class << self
+        def fit_keyword; :Fit; end
+      end
+      register_as
+    end
+
+    # /FitH top — fit width, top at +top+.
+    class FitHorizontal < Fit
+      attr_reader :top
+
+      def initialize(page_ref, top: nil)
+        super(page_ref)
+        @top = top
+      end
+
+      class << self
+        def fit_keyword; :FitH; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitH, @top].compact)
+      end
+      register_as
+    end
+
+    # /FitV left — fit height, left at +left+.
+    class FitVertical < Fit
+      attr_reader :left
+
+      def initialize(page_ref, left: nil)
+        super(page_ref)
+        @left = left
+      end
+
+      class << self
+        def fit_keyword; :FitV; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitV, @left].compact)
+      end
+      register_as
+    end
+
+    # /FitR left bottom right top — fit the specified rectangle.
+    class FitRectangle < Fit
+      attr_reader :left, :bottom, :right, :top
+
+      def initialize(page_ref, left:, bottom:, right:, top:)
+        super(page_ref)
+        @left = left
+        @bottom = bottom
+        @right = right
+        @top = top
+      end
+
+      class << self
+        def fit_keyword; :FitR; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitR, @left, @bottom, @right, @top])
+      end
+      register_as
+    end
+
+    # /XYZ left top zoom — explicit position and zoom.
+    class XYZ < Fit
+      attr_reader :left, :top, :zoom
+
+      def initialize(page_ref, left: nil, top: nil, zoom: nil)
+        super(page_ref)
+        @left = left
+        @top = top
+        @zoom = zoom
+      end
+
+      class << self
+        def fit_keyword; :XYZ; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :XYZ, @left, @top, @zoom].compact)
+      end
+      register_as
+    end
+
+    # /FitB — fit the bounding box of the page contents.
+    class FitBoundingBox < Fit
+      class << self
+        def fit_keyword; :FitB; end
+      end
+      register_as
+    end
+
+    # /FitBH top — fit bounding box width, top at +top+.
+    class FitBoundingBoxHorizontal < Fit
+      attr_reader :top
+
+      def initialize(page_ref, top: nil)
+        super(page_ref)
+        @top = top
+      end
+
+      class << self
+        def fit_keyword; :FitBH; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitBH, @top].compact)
+      end
+      register_as
+    end
+
+    # /FitBV left — fit bounding box height, left at +left+.
+    class FitBoundingBoxVertical < Fit
+      attr_reader :left
+
+      def initialize(page_ref, left: nil)
+        super(page_ref)
+        @left = left
+      end
+
+      class << self
+        def fit_keyword; :FitBV; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitBV, @left].compact)
+      end
+      register_as
+    end
+  end
+end

data/lib/pdfrb/destination.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Destinations (ISO 32000-2 §12.3.2). A destination specifies a view
+  # of a page: which page, how to fit it in the viewport, and optional
+  # position/zoom parameters.
+  #
+  # Each fit type is a value object that serializes to a PDF destination
+  # array: [page_ref /Fit], [page_ref /XYZ x y zoom], etc.
+  module Destination
+    autoload :Fit, "pdfrb/destination/fit"
+  end
+end

data/lib/pdfrb/digital_signature/cms_handler.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module DigitalSignature
+    module CmsHandler
+      module_function
+
+      def type; :"adbe.pkcs7.detached"; end
+
+      def sign(document, cert:, key:, **)
+        Pdfrb::DigitalSignature::Signing.sign(document, cert: cert, key: key, **)
+      end
+
+      def verify(signature_data, signed_data, trusted_certs: [])
+        pkcs7 = OpenSSL::PKCS7.new(signature_data)
+        store = OpenSSL::X509::Store.new
+        trusted_certs.each { |c| store.add_cert(c) }
+        pkcs7.verify(nil, store, signed_data, OpenSSL::PKCS7::DETACHED)
+      end
+    end
+  end
+end

data/lib/pdfrb/digital_signature/signing.rb

@@ -1,28 +1,124 @@
 # frozen_string_literal: true
 
 require "openssl"
+require "stringio"
 
 module Pdfrb
   module DigitalSignature
-    # PKCS#7 signing (s12.8.3). Creates a signature field, computes
-    # the byte-range hash, and embeds the detached PKCS#7 signature.
     module Signing
+      PLACEHOLDER_HEX_LEN = 8192
+
       module_function
 
-      def sign(document, cert:, key:, **_opts)
+      def sign(document, cert:, key:, reason: nil, name: nil)
         raise Pdfrb::Error, "OpenSSL cert required" unless cert.is_a?(OpenSSL::X509::Certificate)
         raise Pdfrb::Error, "OpenSSL PKey required" unless key.is_a?(OpenSSL::PKey::PKey)
 
-        # Create a signature field (widget annotation).
-        sig_dict = document.add(
-          {
-            Type: :Sig,
-            Filter: :Adobe.PPKLite,
-            SubFilter: :adbe.pkcs7.detached
-          },
+        sig_dict = build_sig_dict(document, reason: reason, name: name)
+        attach_to_acroform(document, sig_dict)
+
+        pdf = serialize(document)
+        pdf = insert_contents_placeholder(pdf, sig_dict.oid)
+        finalize_signature(pdf, cert, key)
+      end
+
+      def build_sig_dict(document, reason:, name:)
+        hash = {
+          Type: :Sig,
+          Filter: :"Adobe.PPKLite",
+          SubFilter: :"adbe.pkcs7.detached",
+          ByteRange: [0, 0, 0, 0],
+        }
+        hash[:Reason] = reason if reason
+        hash[:Name] = name if name
+        hash[:M] = "D:#{Time.now.utc.strftime("%Y%m%d%H%M%S+00'00'")}"
+        document.add(hash, type: Pdfrb::Model::Cos::Dictionary)
+      end
+
+      def attach_to_acroform(document, sig_dict)
+        catalog = document.catalog
+        catalog.value[:AcroForm] ||= {}
+        catalog.value[:AcroForm][:SigFlags] = 3
+        catalog.value[:AcroForm][:Fields] ||= []
+
+        field = document.add(
+          { Type: :Annot, Subtype: :Widget, FT: :Sig, T: "Signature1",
+            V: Pdfrb::Model::Reference.new(sig_dict.oid, sig_dict.gen),
+            Rect: [0, 0, 0, 0] },
           type: Pdfrb::Model::Cos::Dictionary
         )
-        sig_dict
+        catalog.value[:AcroForm][:Fields] <<
+          Pdfrb::Model::Reference.new(field.oid, field.gen)
+      end
+
+      def serialize(document)
+        io = StringIO.new
+        Pdfrb::Writer.write(document, io)
+        io.string
+      end
+
+      def insert_contents_placeholder(pdf, sig_oid)
+        sig_pattern = "#{sig_oid} 0 obj"
+        sig_start = pdf.index(sig_pattern)
+        return pdf unless sig_start
+
+        dict_end = pdf.index(">>", sig_start)
+        return pdf unless dict_end
+
+        placeholder = "0" * PLACEHOLDER_HEX_LEN
+        contents_str = "/Contents <#{placeholder}>"
+
+        "#{pdf[0, dict_end + 2]}\n#{contents_str}#{pdf[(dict_end + 2)..]}"
+      end
+
+      def finalize_signature(pdf, cert, key)
+        marker = "/Contents <"
+        contents_marker = pdf.index(marker)
+        return pdf unless contents_marker
+
+        hex_start = contents_marker + marker.bytesize
+        hex_end = pdf.index(">", hex_start)
+        return pdf unless hex_end
+
+        part1_end = hex_start
+        part2_start = hex_end + 1
+        part2_len = pdf.bytesize - part2_start
+
+        br_old = "/ByteRange [0 0 0 0]"
+        br_new = "/ByteRange [0 #{part1_end} #{part2_start} #{part2_len}]"
+        size_diff = br_new.bytesize - br_old.bytesize
+
+        if size_diff.positive?
+          part1_end += size_diff
+          part2_start += size_diff
+          br_new = "/ByteRange [0 #{part1_end} #{part2_start} #{part2_len}]"
+          new_size_diff = br_new.bytesize - br_old.bytesize
+          if new_size_diff != size_diff
+            adjust = new_size_diff - size_diff
+            part1_end += adjust
+            part2_start += adjust
+            br_new = "/ByteRange [0 #{part1_end} #{part2_start} #{part2_len}]"
+          end
+        elsif size_diff.negative?
+          br_new = br_new.ljust(br_old.bytesize)
+        end
+
+        pdf = pdf.sub(br_old, br_new)
+
+        hex_start = part1_end
+        hex_end = pdf.index(">", hex_start)
+        hex_len = hex_end - hex_start
+
+        signed_data = pdf.bytes[0, part1_end].pack("C*") +
+          pdf.bytes[part2_start, part2_len].pack("C*")
+
+        der = OpenSSL::PKCS7.sign(cert, key, signed_data, [],
+                                  OpenSSL::PKCS7::DETACHED |
+                                  OpenSSL::PKCS7::BINARY).to_der
+
+        hex_sig = der.unpack1("H*").ljust(hex_len, "0")
+
+        pdf[0, hex_start] + hex_sig + pdf[hex_end..]
       end
     end
   end

data/lib/pdfrb/digital_signature/timestamp_handler.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module DigitalSignature
+    module TimestampHandler
+      module_function
+
+      def type; :"adbe.revision"; end
+
+      def create_timestamp(data, tsa_url: nil)
+        return nil unless tsa_url
+
+        require "net/http"
+        require "uri"
+
+        uri = URI(tsa_url)
+        response = Net::HTTP.start(uri.host, uri.port) do |http|
+          req = Net::HTTP::Post.new(uri.request_uri)
+          req["Content-Type"] = "application/timestamp-query"
+          req.body = build_tsr_request(data)
+          http.request(req)
+        end
+
+        response.body if response.is_a?(Net::HTTPSuccess)
+      end
+
+      def build_tsr_request(data)
+        require "openssl"
+        hash = OpenSSL::Digest.new("SHA256")
+        req = OpenSSL::ASN1::Sequence.new([
+                                            OpenSSL::ASN1::Integer.new(1),
+                                            OpenSSL::ASN1::Sequence.new([
+                                                                          OpenSSL::ASN1::Sequence.new([
+                                                                                                        OpenSSL::ASN1::ObjectId.new("2.16.840.1.101.3.4.2.1"),
+                                                                                                        OpenSSL::ASN1::OctetString.new(hash.digest(data).force_encoding("BINARY")),
+                                                                                                      ]),
+                                                                        ]),
+                                            OpenSSL::ASN1::Integer.new(0),
+                                            OpenSSL::ASN1::Boolean.new(false),
+                                          ])
+        req.to_der
+      end
+    end
+  end
+end