pdfrb 0.2.1 → 0.6.0

data/lib/pdfrb/model/type/embedded_file_parameter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # EmbeddedFileParameterDictionary (s7.11.3.1). Per /EF entry
+      # /Params dict — checksum, size, dates, mac creator.
+      class EmbeddedFileParameter < Pdfrb::Model::Cos::Dictionary
+        def size; self[:Size]; end
+        def creation_date; self[:CreationDate]; end
+        def modification_date; self[:ModDate]; end
+        def mac; self[:Mac]; end
+        def checksum; self[:CheckSum]; end
+
+        def has_checksum?
+          !!checksum
+        end
+
+        def creation_time
+          time = creation_date
+          return nil unless time
+
+          time.is_a?(Time) ? time : parse_pdf_date(time.to_s)
+        end
+
+        def modification_time
+          time = modification_date
+          return nil unless time
+
+          time.is_a?(Time) ? time : parse_pdf_date(time.to_s)
+        end
+
+        private
+
+        def parse_pdf_date(str)
+          match = str.to_s.match(/^D:(\d{4})(\d{2})(\d{2})(\d{2})?(\d{2})?(\d{2})?/)
+          return nil unless match
+
+          Time.new(match[1].to_i, match[2].to_i, match[3].to_i,
+                   (match[4] || 0).to_i, (match[5] || 0).to_i, (match[6] || 0).to_i,
+                   "+00:00")
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/encryption_public_key.rb

@@ -6,6 +6,44 @@ module Pdfrb
       # Public-key security handler encryption dict (s7.6.5.1).
       class EncryptionPublicKey < Pdfrb::Model::Cos::Dictionary
         arlington_object "EncryptionPublicKey"
+
+        def filter; self[:Filter]; end
+        def version; self[:V]; end
+        def sub_filter; self[:SubFilter]; end
+        def length; self[:Length]; end
+        def recipients; self[:Recipients]; end
+        def encrypt_metadata?; truthy?(self[:EncryptMetadata]); end
+
+        def public_key?
+          filter&.to_sym == :AdobePubSec
+        end
+
+        def s2?
+          sub_filter&.to_sym == :S2
+        end
+
+        def s3?
+          sub_filter&.to_sym == :S3
+        end
+
+        def s4?
+          sub_filter&.to_sym == :S4
+        end
+
+        def recipient_count
+          return 0 unless recipients
+
+          arr = recipients.is_a?(Pdfrb::Model::PdfArray) ? recipients.to_a : recipients
+          arr.is_a?(Array) ? arr.size : 0
+        end
+
+        def key_length_bytes
+          ((length || 40) / 8)
+        end
+
+        def aes?
+          (version || 0) >= 4
+        end
       end
     end
   end

data/lib/pdfrb/model/type/encryption_standard.rb

@@ -6,6 +6,74 @@ module Pdfrb
       # Standard security handler encryption dict (s7.6.3.4).
       class EncryptionStandard < Pdfrb::Model::Cos::Dictionary
         arlington_object "EncryptionStandard"
+
+        def filter; self[:Filter]; end
+        def sub_filter; self[:SubFilter]; end
+        def version; self[:V]; end
+        def revision; self[:R]; end
+        def length; self[:Length]; end
+        def permissions; self[:P]; end
+        def owner_password; self[:O]; end
+        def user_password; self[:U]; end
+        def encrypt_metadata?; self[:EncryptMetadata]; end
+        def recipient_info; self[:Recipients]; end
+
+        def key_length_bytes
+          ((length || 40) / 8)
+        end
+
+        def aes?
+          (version || 0) >= 4
+        end
+
+        def rc4?
+          (version || 0) < 4
+        end
+
+        def public_key?
+          filter&.to_sym == :AdobePubSec
+        end
+
+        def standard?
+          filter&.to_sym == :Standard
+        end
+
+        def metadata_encrypted?
+          value = encrypt_metadata?
+          value.nil? || !!value
+        end
+
+        def allow_print?
+          permissions&.anybits?(4)
+        end
+
+        def allow_modify_contents?
+          permissions&.anybits?(8)
+        end
+
+        def allow_copy?
+          permissions&.anybits?(16)
+        end
+
+        def allow_annotations?
+          permissions&.anybits?(32)
+        end
+
+        def allow_fill_in?
+          permissions&.anybits?(256)
+        end
+
+        def allow_extract?
+          permissions&.anybits?(512)
+        end
+
+        def allow_assemble?
+          permissions&.anybits?(1024)
+        end
+
+        def allow_print_high_res?
+          permissions&.anybits?(2048)
+        end
       end
     end
   end

data/lib/pdfrb/model/type/field_mdp_transform_parameters.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Field MDP Transform Parameters (s12.7.6.5). Specifies which
+      # fields are locked by a FieldMDP signature reference.
+      class FieldMDPTransformParameters < Pdfrb::Model::Cos::Dictionary
+        def type; self[:Type]; end
+        def action; self[:Action]&.to_sym; end
+        def fields; self[:Fields]; end
+
+        def all_locked?; action == :All; end
+        def include_locked?; action == :Include; end
+        def exclude_locked?; action == :Exclude; end
+
+        def locked_field_names
+          return [] unless fields
+
+          arr = fields.is_a?(Pdfrb::Model::PdfArray) ? fields.to_a : fields
+          arr.is_a?(Array) ? arr : []
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/file_attachment_annotation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # File-attachment annotation (s12.5.6.15). Embedded file displayed
+      # as a paper-clip icon.
+      class FileAttachmentAnnotation < MarkupAnnotation
+        def embedded_file; self[:FS]; end
+        def name; self[:Name]; end
+
+        def icon_name
+          (name || :PushPin).to_sym
+        end
+
+        def has_attachment?
+          !!embedded_file
+        end
+
+        def resolved_file_spec
+          ref = embedded_file
+          return nil unless ref && document
+
+          document.object(ref)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/file_spec_ef.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Filespec EF dict (s7.11.2.2). Maps variant file type to
+      # EmbeddedFile stream reference: /F (type 1), /UF (Unicode),
+      # /DOS, /Mac, /Unix.
+      class FileSpecEF < Pdfrb::Model::Cos::Dictionary
+        def primary_file; self[:F]; end
+        def unicode_file; self[:UF]; end
+        def dos_file; self[:DOS]; end
+        def mac_file; self[:Mac]; end
+        def unix_file; self[:Unix]; end
+
+        def any?
+          !!(primary_file || unicode_file || dos_file || mac_file || unix_file)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/file_spec_rf.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Filespec RF dict (s7.11.2.3). Related files name tree.
+      class FileSpecRF < Pdfrb::Model::Cos::Dictionary
+        def related_files; self[:Names]; end
+
+        def each_related(&block)
+          return enum_for(:each_related) unless block
+
+          return unless related_files
+
+          arr = related_files.is_a?(Pdfrb::Model::PdfArray) ? related_files.to_a : related_files
+          arr.each_slice(2, &block)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/file_specification.rb

@@ -6,6 +6,49 @@ module Pdfrb
       # File specification (s7.11.2). /FS, /F, /UF, /EF, /Desc, etc.
       class FileSpecification < Pdfrb::Model::Cos::Dictionary
         arlington_object "FileSpecification"
+        register_type :Filespec
+
+        def file_system; self[:FS]; end
+        def file; self[:F]; end
+        def unicode_file; self[:UF]; end
+        def dos_file; self[:DOS]; end
+        def mac_file; self[:Mac]; end
+        def unix_file; self[:Unix]; end
+        def id; self[:ID]; end
+        def volatile; self[:V]; end
+        def embedded_file; self[:EF]; end
+        def related_files; self[:RF]; end
+        def description; self[:Desc]; end
+        def collection; self[:Collection]; end
+        def type; self[:Type]; end
+
+        def simple?
+          !!(file || unicode_file)
+        end
+
+        def url?
+          file_system&.to_sym == :URL
+        end
+
+        def effective_filename
+          unicode_file || file || dos_file || mac_file || unix_file
+        end
+
+        def effective_embedded_file
+          return nil unless embedded_file
+
+          mapping = if embedded_file.is_a?(Pdfrb::Model::Reference) && document
+                      document.object(embedded_file)
+                    else
+                      embedded_file
+                    end
+          return nil unless mapping.is_a?(Hash)
+
+          ref = mapping[:UF] || mapping[:F]
+          return nil unless ref && document
+
+          document.object(ref)
+        end
       end
     end
   end

data/lib/pdfrb/model/type/file_trailer.rb

@@ -8,6 +8,60 @@ module Pdfrb
       # /AuthCode, /AdditionalStreams, /DocChecksum.
       class FileTrailer < Pdfrb::Model::Cos::Dictionary
         arlington_object "FileTrailer"
+        register_type :FileTrailer
+
+        def size; self[:Size]; end
+        def prev; self[:Prev]; end
+        def root; self[:Root]; end
+        def encrypt; self[:Encrypt]; end
+        def info; self[:Info]; end
+        def id; self[:ID]; end
+        def xref_stream_offset; self[:XRefStm]; end
+        def doc_checksum; self[:DocChecksum]; end
+
+        def encrypted?
+          !!encrypt
+        end
+
+        def incremental?
+          !!prev
+        end
+
+        def has_id?
+          id.is_a?(Array) && id.size == 2
+        end
+
+        def original_id
+          return nil unless has_id?
+
+          arr = id.is_a?(Pdfrb::Model::PdfArray) ? id.to_a : id
+          arr[0]
+        end
+
+        def current_id
+          return nil unless has_id?
+
+          arr = id.is_a?(Pdfrb::Model::PdfArray) ? id.to_a : id
+          arr[1] || arr[0]
+        end
+
+        def resolved_root
+          return nil unless root && document
+
+          document.object(root)
+        end
+
+        def resolved_info
+          return nil unless info && document
+
+          document.object(info)
+        end
+
+        def resolved_encrypt
+          return nil unless encrypt && document
+
+          document.object(encrypt)
+        end
       end
     end
   end

data/lib/pdfrb/model/type/font.rb

@@ -3,10 +3,81 @@
 module Pdfrb
   module Model
     module Type
-      # Base Font dict (s9.6.2). Concrete subclasses: FontType1,
-      # FontTrueType, FontType0, CIDFont, FontType3.
       class Font < Pdfrb::Model::Cos::Dictionary
         arlington_object "FontMap"
+
+        def subtype; self[:Subtype]; end
+        def base_font; self[:BaseFont]; end
+        def encoding; self[:Encoding]; end
+        def first_char; self[:FirstChar]; end
+        def last_char; self[:LastChar]; end
+        def widths; self[:Widths]; end
+        def to_unicode; self[:ToUnicode]; end
+
+        def font_descriptor
+          ref = self[:FontDescriptor]
+          return nil unless ref
+
+          document ? document.object(ref) : ref
+        end
+
+        def embedded?
+          fd = font_descriptor
+          return false unless fd
+
+          !!(fd.value[:FontFile] || fd.value[:FontFile2] || fd.value[:FontFile3])
+        end
+
+        def font_file
+          fd = font_descriptor
+          return nil unless fd
+
+          fd.value[:FontFile2] || fd.value[:FontFile3] || fd.value[:FontFile]
+        end
+
+        def simple?
+          [:Type1, :TrueType, :MMType1].include?(subtype&.to_sym)
+        end
+
+        def cid?
+          subtype&.to_sym == :Type0
+        end
+
+        def type3?
+          subtype&.to_sym == :Type3
+        end
+
+        def descendant_font
+          return nil unless cid?
+
+          ref = self[:DescendantFonts]
+          return nil unless ref
+
+          arr = if ref.is_a?(Pdfrb::Model::Reference) && document
+                  document.object(ref)
+                else
+                  ref
+                end
+          return nil unless arr.is_a?(Array) || arr.is_a?(Pdfrb::Model::PdfArray)
+
+          first = arr[0]
+          return nil unless first
+
+          if first.is_a?(Pdfrb::Model::Reference) && document
+            document.object(first)
+          else
+            first
+          end
+        end
+
+        def glyph_width(char_code)
+          return nil unless widths && first_char && last_char
+
+          idx = char_code - first_char
+          return nil if idx.negative? || idx >= widths.length
+
+          widths[idx]
+        end
       end
     end
   end

data/lib/pdfrb/model/type/font_cid_type0.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Font CIDType0 (s9.7.3). CIDFontType0 — CID-keyed font based
+      # on CFF (Compact Font Format).
+      class FontCIDType0 < CIDFont
+        def cid_subtype; self[:Subtype]&.to_sym; end
+
+        def cff?
+          cid_subtype == :CIDFontType0
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/font_cid_type2.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Font CIDType2 (s9.7.3). CIDFontType2 — CID-keyed font based
+      # on TrueType outlines.
+      class FontCIDType2 < CIDFont
+        def cid_subtype; self[:Subtype]&.to_sym; end
+
+        def true_type?
+          cid_subtype == :CIDFontType2
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/font_descriptor.rb

@@ -6,6 +6,53 @@ module Pdfrb
       # Font descriptor (s9.8). Carries metrics + embedded font file.
       class FontDescriptor < Pdfrb::Model::Cos::Dictionary
         arlington_object "FontDescriptorType1"
+
+        def font_name; self[:FontName]; end
+        def family_name; self[:FontFamily]; end
+        def font_stretch; self[:FontStretch]; end
+        def font_weight; self[:FontWeight]; end
+        def flags; self[:Flags]; end
+        def font_bbox; self[:FontBBox]; end
+        def italic_angle; self[:ItalicAngle]; end
+        def ascent; self[:Ascent]; end
+        def descent; self[:Descent]; end
+        def cap_height; self[:CapHeight]; end
+        def x_height; self[:XHeight]; end
+        def stem_v; self[:StemV]; end
+        def stem_h; self[:StemH]; end
+        def avg_width; self[:AvgWidth]; end
+        def max_width; self[:MaxWidth]; end
+        def missing_width; self[:MissingWidth]; end
+        def char_set; self[:CharSet]; end
+
+        def font_file; self[:FontFile]; end
+        def font_file2; self[:FontFile2]; end
+        def font_file3; self[:FontFile3]; end
+
+        def embedded?
+          !!(font_file || font_file2 || font_file3)
+        end
+
+        def font_file_reference
+          font_file2 || font_file3 || font_file
+        end
+
+        def resolved_font_file
+          ref = font_file_reference
+          return nil unless ref && document
+
+          document.object(ref)
+        end
+
+        def fixed_pitch?; flags&.anybits?(1); end
+        def serif?; flags&.anybits?(2); end
+        def symbolic?; flags&.anybits?(4); end
+        def script?; flags&.anybits?(8); end
+        def nonsymbolic?; flags&.anybits?(32); end
+        def italic?; flags&.anybits?(64); end
+        def all_cap?; flags&.anybits?(0x10000); end
+        def small_cap?; flags&.anybits?(0x20000); end
+        def force_bold?; flags&.anybits?(0x40000); end
       end
     end
   end

data/lib/pdfrb/model/type/font_descriptor_cid_type0.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Font Descriptor CIDType0 (s9.8). Specialised metrics for
+      # CIDFontType0 (CFF-based CID fonts).
+      class FontDescriptorCIDType0 < FontDescriptor
+        def cid_font_type; 0; end
+
+        def cff?; true; end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/font_descriptor_cid_type2.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Font Descriptor CIDType2 (s9.8). Specialised metrics for
+      # CIDFontType2 (TrueType-based CID fonts).
+      class FontDescriptorCIDType2 < FontDescriptor
+        def cid_font_type; 2; end
+
+        def true_type?; true; end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/font_encoding.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Font Encoding dict (s9.6.1). Base encoding + per-glyph differences
+      # table for Type 1 fonts.
+      class FontEncoding < Pdfrb::Model::Cos::Dictionary
+        def base_encoding; self[:BaseEncoding]&.to_sym; end
+        def differences; self[:Differences]; end
+
+        def win_ansi?; base_encoding == :WinAnsiEncoding; end
+        def mac_roman?; base_encoding == :MacRomanEncoding; end
+        def mac_expert?; base_encoding == :MacExpertEncoding; end
+        def standard?; base_encoding == :StandardEncoding; end
+
+        def has_differences?
+          !!differences && (!differences.is_a?(Array) || !differences.empty?)
+        end
+
+        def each_difference(&block)
+          return enum_for(:each_difference) unless block
+
+          return unless differences.is_a?(Array)
+
+          current_code = nil
+          differences.each do |entry|
+            if entry.is_a?(Integer)
+              current_code = entry
+            else
+              yield current_code, entry
+              current_code = current_code ? current_code + 1 : nil
+            end
+          end
+        end
+
+        def glyph_for(char_code)
+          result = nil
+          each_difference do |code, name|
+            result = name if code == char_code
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/font_file.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 1 font file stream (s7.8.2). Holds the Type1 / Type1C
+      # font program. Referenced by FontDescriptor /FontFile.
+      class FontFile < Pdfrb::Model::Cos::Stream
+        def length1; self[:Length1]; end
+        def length2; self[:Length2]; end
+        def length3; self[:Length3]; end
+        def subtype; self[:Subtype]; end
+
+        def has_clear_text_mark?
+          !!length1 && length1.positive?
+        end
+
+        def has_encrypted_portion?
+          !!length2 && length2.positive?
+        end
+
+        def font_program
+          decoded_stream&.force_encoding(Encoding::BINARY)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/font_file2.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # TrueType font file stream (s7.8.3). Holds the TTF/OTF program.
+      # Referenced by FontDescriptor /FontFile2.
+      class FontFile2 < Pdfrb::Model::Cos::Stream
+        def length1; self[:Length1]; end
+        def subtype; self[:Subtype]; end
+
+        def font_program
+          decoded_stream&.force_encoding(Encoding::BINARY)
+        end
+
+        def magic
+          return nil unless stream
+
+          stream.byteslice(0, 4)
+        end
+
+        def truetype?
+          magic == "\x00\x01\x00\x00".b || magic == "true".b
+        end
+
+        def opentype?
+          magic == "OTTO".b
+        end
+      end
+    end
+  end
+end