pdfrb 0.1.0

data/lib/pdfrb/filter/lzw_decode.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Filter
+    # LZWDecode (s7.4.4). LZW decompression with optional DeLZW
+    # predictor handling (same PNG predictor as FlateDecode).
+    class LZWDecode
+      include Base
+
+      register_as "LZWDecode"
+
+      CLEAR_TABLE = 256
+      EOD_MARKER  = 257
+      INITIAL_DICT_SIZE = 258
+
+      class << self
+        def decoder(bytes, parms, _document)
+          decoded = decompress(bytes)
+          apply_predictor(decoded, parms)
+        end
+
+        def encoder(_bytes, _parms, _document)
+          raise Pdfrb::FilterError.new(
+            "LZWDecode encoder not implemented",
+            filter_name: "LZWDecode"
+          )
+        end
+
+        private
+
+        def decompress(bytes)
+          out = +""
+          table = build_initial_table
+          next_code = INITIAL_DICT_SIZE
+          bit_width = 9
+          early_change = 1 # default per spec
+          bit_iter = BitReader.new(bytes)
+          prev = nil
+
+          while (code = bit_iter.read_bits(bit_width))
+            break if code == EOD_MARKER
+
+            if code == CLEAR_TABLE
+              table = build_initial_table
+              next_code = INITIAL_DICT_SIZE
+              bit_width = 9
+              prev = nil
+              next
+            end
+
+            entry =
+              if code < table.length
+                table[code]
+              elsif code == table.length && prev
+                prev + prev.byteslice(0, 1)
+              else
+                raise Pdfrb::FilterError.new(
+                  "LZWDecode bad code #{code}",
+                  filter_name: "LZWDecode"
+                )
+              end
+            out << entry
+            if prev && next_code < 4096
+              table << prev + entry.byteslice(0, 1)
+              next_code += 1
+              bit_width = compute_bit_width(next_code, early_change) if next_code > (1 << bit_width) - 1 - early_change + 1
+            end
+            prev = entry
+          end
+          out.force_encoding(Encoding::BINARY)
+        end
+
+        def build_initial_table
+          (0..255).map(&:chr).map { |s| s.force_encoding(Encoding::BINARY) }
+        end
+
+        def compute_bit_width(next_code, early_change)
+          w = 9
+          w += 1 while next_code > (1 << w) - 1 - early_change
+          w.clamp(9, 12)
+        end
+
+        def apply_predictor(bytes, parms)
+          return bytes unless parms && parms.is_a?(::Hash)
+
+          predictor = parms[:Predictor] || 1
+          return bytes if predictor == 1
+
+          Pdfrb::Filter::FlateDecode.send(:apply_png_predictor_decode,
+            bytes,
+            predictor: predictor,
+            columns: parms[:Columns] || 1,
+            colors: parms[:Colors] || 1,
+            bits_per_component: parms[:BitsPerComponent] || 8)
+        end
+      end
+
+      # Pull-based bit reader for LZW bit-streams.
+      class BitReader
+        def initialize(bytes)
+          @bytes = bytes.bytes
+          @bit_pos = 0
+        end
+
+        def read_bits(width)
+          result = 0
+          bits_read = 0
+          while bits_read < width
+            byte_index = @bit_pos / 8
+            return nil if byte_index >= @bytes.length
+
+            bit_in_byte = 7 - (@bit_pos % 8)
+            bit = (@bytes[byte_index] >> bit_in_byte) & 1
+            result = (result << 1) | bit
+            @bit_pos += 1
+            bits_read += 1
+          end
+          result
+        end
+      end
+      private_constant :BitReader
+    end
+  end
+end

data/lib/pdfrb/filter/passthrough_filters.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Filter
+    DCTDecode = Class.new do
+      include Base
+      register_as "DCTDecode"
+      class << self
+        def decoder(bytes, _parms, _document); bytes; end
+        def encoder(bytes, _parms, _document); bytes; end
+      end
+    end.freeze
+    public_constant :DCTDecode
+
+    JPXDecode = Class.new do
+      include Base
+      register_as "JPXDecode"
+      class << self
+        def decoder(bytes, _parms, _document); bytes; end
+        def encoder(bytes, _parms, _document); bytes; end
+      end
+    end.freeze
+    public_constant :JPXDecode
+
+    JBIG2Decode = Class.new do
+      include Base
+      register_as "JBIG2Decode"
+      class << self
+        def decoder(bytes, _parms, _document); bytes; end
+        def encoder(bytes, _parms, _document); bytes; end
+      end
+    end.freeze
+    public_constant :JBIG2Decode
+
+    CCITTFaxDecode = Class.new do
+      include Base
+      register_as "CCITTFaxDecode"
+      class << self
+        def decoder(bytes, _parms, _document)
+          raise Pdfrb::FilterError.new(
+            "CCITTFaxDecode requires an external decoder (Group 3/4 fax)",
+            filter_name: "CCITTFaxDecode"
+          )
+        end
+        def encoder(_bytes, _parms, _document)
+          raise Pdfrb::FilterError.new(
+            "CCITTFaxDecode encoder not implemented",
+            filter_name: "CCITTFaxDecode"
+          )
+        end
+      end
+    end.freeze
+    public_constant :CCITTFaxDecode
+  end
+end

data/lib/pdfrb/filter/run_length_decode.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Filter
+    # RunLengthDecode (s7.4.5). Length byte 0..127 = N+1 literal bytes;
+    # 129..255 = repeat next byte (257 - N) times; 128 = EOD.
+    class RunLengthDecode
+      include Base
+
+      register_as "RunLengthDecode"
+
+      class << self
+        def decoder(bytes, _parms, _document)
+          out = +""
+          i = 0
+          bs = bytes.bytes
+          while i < bs.length
+            n = bs[i]
+            i += 1
+            case n
+            when 128 then break
+            when 0..127
+              out << bs[i, n + 1].pack("C*")
+              i += n + 1
+            when 129..255
+              count = 257 - n
+              out << (bs[i] || 0).chr * count if count.positive? && bs[i]
+              i += 1
+            end
+          end
+          out.force_encoding(Encoding::BINARY)
+        end
+
+        def encoder(bytes, _parms, _document)
+          out = +""
+          bs = bytes.bytes
+          i = 0
+          while i < bs.length
+            # Try to find a run of identical bytes (3+).
+            run_len = 1
+            while i + run_len < bs.length && bs[i + run_len] == bs[i] && run_len < 128
+              run_len += 1
+            end
+            if run_len >= 3
+              out << (257 - run_len).chr
+              out << bs[i].chr
+              i += run_len
+            else
+              # Accumulate literals until next run or 128 bytes.
+              literal = []
+              while i < bs.length && literal.length < 128
+                # Stop if a run of >= 3 starts.
+                ahead_run = 0
+                while i + ahead_run < bs.length && bs[i + ahead_run] == bs[i] && ahead_run < 3
+                  ahead_run += 1
+                end
+                break if ahead_run >= 3
+
+                literal << bs[i]
+                i += 1
+              end
+              out << (literal.length - 1).chr
+              out << literal.pack("C*")
+            end
+          end
+          out << 128.chr # EOD
+          out.force_encoding(Encoding::BINARY)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/filter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Stream filter pipeline (s7.4). Each filter is a stateless class
+  # with `decoder(bytes, parms, document)` and `encoder(bytes, parms,
+  # document)` class methods, registered via `register_as`.
+  module Filter
+    autoload :Base, "pdfrb/filter/base"
+
+    class << self
+      def registry; @registry ||= {}; end
+
+      def register(name, klass)
+        registry[name.to_s] = klass
+      end
+
+      def [](name)
+        registry[name.to_s]
+      end
+
+      def apply(bytes, filters:, parms:, direction:, document: nil)
+        return bytes if filters.empty?
+
+        case direction
+        when :decode then decode_chain(bytes, filters, parms, document)
+        when :encode then encode_chain(bytes, filters, parms, document)
+        else raise ArgumentError, "unknown direction #{direction.inspect}"
+        end
+      end
+
+      private
+
+      def decode_chain(bytes, filters, parms, document)
+        filters.each_with_index.reduce(bytes.dup) do |acc, (filter, i)|
+          klass = self[filter] or raise Pdfrb::FilterError.new(
+            "unknown filter #{filter.inspect}", filter_name: filter.to_s
+          )
+          klass.decoder(acc, parms[i], document)
+        end
+      end
+
+      def encode_chain(bytes, filters, _parms, document)
+        filters.reverse_each.reduce(bytes.dup) do |acc, filter|
+          klass = self[filter] or raise Pdfrb::FilterError.new(
+            "unknown filter #{filter.inspect}", filter_name: filter.to_s
+          )
+          klass.encoder(acc, nil, document)
+        end
+      end
+    end
+  end
+end
+
+# Eager-load filters so register_as calls populate the registry
+# before any stream decode happens. Must be after the Filter module
+# and its singleton methods are fully defined.
+require "pdfrb/filter/base"
+require "pdfrb/filter/flate_decode"
+require "pdfrb/filter/ascii_hex_decode"
+require "pdfrb/filter/ascii_85_decode"
+require "pdfrb/filter/lzw_decode"
+require "pdfrb/filter/run_length_decode"
+require "pdfrb/filter/crypt"
+require "pdfrb/filter/passthrough_filters"

data/lib/pdfrb/font/afm_parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    # AFM (Adobe Font Metrics) parser. Reads the text-based AFM
+    # format used by the 14 standard Type1 fonts.
+    class AFMParser
+      attr_reader :font_name, :full_name, :family_name,
+                  :encoding_scheme, :bbox, :cap_height, :x_height,
+                  :ascender, :descender, :char_metrics
+
+      def initialize
+        @char_metrics = {}
+      end
+
+      def self.parse(text)
+        new.tap { |p| p.parse(text) }
+      end
+
+      def self.from_file(path)
+        parse(File.read(path, encoding: "UTF-8"))
+      end
+
+      def parse(text)
+        in_char_metrics = false
+        text.each_line do |line|
+          line = line.strip
+          if line.start_with?("FontName ")
+            @font_name = line.split(" ", 2)[1]
+          elsif line.start_with?("FullName ")
+            @full_name = line.split(" ", 2)[1]
+          elsif line.start_with?("FamilyName ")
+            @family_name = line.split(" ", 2)[1]
+          elsif line.start_with?("EncodingScheme ")
+            @encoding_scheme = line.split(" ", 2)[1]
+          elsif line.start_with?("FontBBox ")
+            @bbox = line.split.drop(1).map(&:to_f)
+          elsif line.start_with?("CapHeight ")
+            @cap_height = line.split[1].to_f
+          elsif line.start_with?("XHeight ")
+            @x_height = line.split[1].to_f
+          elsif line.start_with?("Ascender ")
+            @ascender = line.split[1].to_f
+          elsif line.start_with?("Descender ")
+            @descender = line.split[1].to_f
+          elsif line == "StartCharMetrics" || line.start_with?("StartCharMetrics ")
+            in_char_metrics = true
+          elsif line == "EndCharMetrics" || line.start_with?("EndCharMetrics")
+            in_char_metrics = false
+          elsif in_char_metrics && line.start_with?("C ")
+            parse_char_metric(line)
+          end
+        end
+        self
+      end
+
+      def width_for(glyph_name_or_code)
+        metric = @char_metrics[glyph_name_or_code] ||
+                 @char_metrics[glyph_name_or_code.to_i]
+        metric ? metric[:width] : 0
+      end
+
+      private
+
+      def parse_char_metric(line)
+        parts = line.split(";").map(&:strip)
+        code = nil
+        width = 0
+        name = nil
+        parts.each do |part|
+          kv = part.split(" ", 2)
+          case kv[0]
+          when "C" then code = kv[1].to_i
+          when "WX" then width = kv[1].to_f
+          when "N" then name = kv[1]
+          end
+        end
+        metric = { code: code, width: width, name: name }
+        @char_metrics[code] = metric if code && code >= 0
+        @char_metrics[name] = metric if name
+      end
+    end
+  end
+end

data/lib/pdfrb/font/cmap/parser.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module CMap
+      # Minimal CMap text parser. Extracts +begincodespacerange+,
+      # +beginbfchar+, +beginbfrange+ sections into a simple Hash
+      # mapping source codes to target Unicode strings.
+      class Parser
+        attr_reader :cmap_name, :system_info, :codespace, :bfchar, :bfrange
+
+        def initialize
+          @codespace = []
+          @bfchar = {}
+          @bfrange = []
+        end
+
+        def self.parse(text)
+          new.tap { |p| p.parse(text) }
+        end
+
+        def parse(text)
+          text.each_line do |line|
+            stripped = line.strip
+            case stripped
+            when /\/CMapName\s+\/(\S+)/ then @cmap_name = Regexp.last_match(1)
+            when /\Abegincodespacerange/
+              read_section(text, line, :codespacerange)
+            end
+          end
+          parse_bfchar_sections(text)
+          parse_bfrange_sections(text)
+        end
+
+        def decode(code)
+          @bfchar[code]
+        end
+
+        private
+
+        def read_section(text, start_line, kind)
+          # Minimal — a full CMap parser needs state tracking.
+        end
+
+        def parse_bfchar_sections(text)
+          lines = text.each_line.to_a
+          i = 0
+          while i < lines.length
+            if lines[i].strip =~ /\Abeginbfchar\b/
+              i += 1
+              until lines[i].strip == "endbfchar"
+                pair = lines[i].strip.split(/\s+/)
+                if pair.length >= 2
+                  key = hex_to_int(pair[0])
+                  val = hex_to_utf16(pair[1])
+                  @bfchar[key] = val
+                end
+                i += 1
+              end
+            end
+            i += 1
+          end
+        end
+
+        def parse_bfrange_sections(text)
+          # Simplified: parse `<start> <end> <target>` lines.
+          text.each_line do |line|
+            m = line.strip.match(/<([0-9A-Fa-f]+)>\s*<([0-9A-Fa-f]+)>\s*<([0-9A-Fa-f]+)>/)
+            next unless m
+
+            start_code = m[1].to_i(16)
+            end_code = m[2].to_i(16)
+            target_start = m[3].to_i(16)
+            (start_code..end_code).each_with_index do |code, idx|
+              cp = target_start + idx
+              @bfchar[code] = [cp].pack("U") if cp <= 0x10FFFF
+            end
+          end
+        end
+
+        def hex_to_int(str)
+          str.sub(/\A</, "").sub(/>\z/, "").to_i(16)
+        end
+
+        def hex_to_utf16(str)
+          raw = str.sub(/\A</, "").sub(/>\z/, "")
+          if raw.length == 4
+            [raw.to_i(16)].pack("U")
+          else
+            raw.scan(/.{4}/).map { |h| h.to_i(16) }.pack("U*")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/font/cmap/writer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module CMap
+      # Writes a CMap text file from a +bfchar+ mapping. Used when
+      # embedding CID fonts with a subset of glyphs.
+      class Writer
+        attr_reader :cmap_name, :cid_system_info, :mapping
+
+        def initialize(cmap_name:, cid_system_info:, mapping:)
+          @cmap_name = cmap_name
+          @cid_system_info = cid_system_info
+          @mapping = mapping
+        end
+
+        def to_s
+          buffer = +""
+          buffer << "/CIDInit /ProcSet findresource begin\n"
+          buffer << "12 dict begin\n"
+          buffer << "begincmap\n"
+          buffer << "/CIDSystemInfo <<\n"
+          buffer << "  /Registry (Adobe)\n"
+          buffer << "  /Ordering (#{@cid_system_info[:ordering]})\n"
+          buffer << "  /Supplement #{@cid_system_info[:supplement]}\n"
+          buffer << ">> def\n"
+          buffer << "/CMapName /#{@cmap_name} def\n"
+          buffer << "/CMapType 1 def\n"
+          buffer << "1 begincodespacerange\n"
+          buffer << "  <0000> <FFFF>\n"
+          buffer << "endcodespacerange\n"
+          buffer << "#{@mapping.length} beginbfchar\n"
+          @mapping.each do |code, unicode|
+            buffer << "<%04X> <%04X>\n" % [code, unicode]
+          end
+          buffer << "endbfchar\n"
+          buffer << "endcmap\n"
+          buffer << "CMapName currentdict /CMap defineresource pop\n"
+          buffer << "end\n"
+          buffer << "end\n"
+          buffer.force_encoding(Encoding::BINARY)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/font/cmap.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module CMap
+      autoload :Parser, "pdfrb/font/cmap/parser"
+      autoload :Writer, "pdfrb/font/cmap/writer"
+    end
+  end
+end

data/lib/pdfrb/font/encoding/mac_roman_encoding.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module Encoding
+      # MacRomanEncoding (Mac OS Roman, Appendix D.3).
+      module MacRomanEncoding
+        TABLE = (0..127).each_with_object(Array.new(256, nil)) { |i, a| a[i] = i }
+        { 0x80 => 0x00C4, 0x81 => 0x00C5, 0x82 => 0x00C7, 0x83 => 0x00C9,
+          0x84 => 0x00D1, 0x85 => 0x00D6, 0x86 => 0x00DC, 0x87 => 0x00E1,
+          0x88 => 0x00E0, 0x89 => 0x00E2, 0x8A => 0x00E4, 0x8B => 0x00E3,
+          0x8C => 0x00E5, 0x8D => 0x00E7, 0x8E => 0x00E9, 0x8F => 0x00E8
+        }.each { |b, cp| TABLE[b] = cp }
+        (0x90..0xFF).each do |b|
+          TABLE[b] = TABLE[b] || case b
+                                 when 0xD0..0xFF then b + 0x500
+                                 else b
+                                 end
+        end
+        TABLE.map! { |cp| cp || 0x3F }
+        TABLE.freeze
+      end
+    end
+  end
+end

data/lib/pdfrb/font/encoding/pdf_doc_encoding.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module Encoding
+      # PDFDocEncoding table (Appendix D.2). Reuses the StringEncoding
+      # table already defined in +Cos::StringEncoding+ to avoid duplication.
+      module PDFDocEncoding
+        TABLE = Pdfrb::Model::Cos::StringEncoding::PDF_DOC_ENCODING
+          .each_with_index.each_with_object(Array.new(256, nil)) do |((cp, byte), _), arr|
+            arr[byte] = cp if cp
+          end.freeze
+      end
+    end
+  end
+end

data/lib/pdfrb/font/encoding/standard_encoding.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module Encoding
+      # StandardEncoding (Adobe Standard, Appendix D.4).
+      # Maps glyph names to byte positions.
+      module StandardEncoding
+        GLYPH_NAMES = {
+          0x20 => "space", 0x21 => "exclam", 0x22 => "quotedbl",
+          0x23 => "numbersign", 0x24 => "dollar", 0x25 => "percent",
+          0x26 => "ampersand", 0x27 => "quoteright", 0x28 => "parenleft",
+          0x29 => "parenright", 0x2A => "asterisk", 0x2B => "plus",
+          0x2C => "comma", 0x2D => "hyphen", 0x2E => "period",
+          0x2F => "slash", (0x30..0x39).map { |d| [d, ("0".ord + d - 0x30).chr] } => nil
+        }.freeze
+
+        TABLE = (0..255).each_with_object(Array.new(256, nil)) do |i, arr|
+          arr[i] = i if i < 0x80
+        end.freeze
+      end
+    end
+  end
+end

data/lib/pdfrb/font/encoding/win_ansi_encoding.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module Encoding
+      # WinAnsiEncoding (Windows Code Page 1252, Appendix D.1).
+      module WinAnsiEncoding
+        TABLE = (0..255).each_with_object(Array.new(256, nil)) do |i, arr|
+          arr[i] = i if i < 0x80
+        end
+        # High-byte mappings (subset — full table is in Windows-1252 spec).
+        { 0x80 => 0x20AC, 0x82 => 0x201A, 0x83 => 0x0192, 0x84 => 0x201E,
+          0x85 => 0x2026, 0x86 => 0x2020, 0x87 => 0x2021, 0x88 => 0x02C6,
+          0x89 => 0x2030, 0x8A => 0x0160, 0x8B => 0x2039, 0x8C => 0x0152,
+          0x8E => 0x017D, 0x91 => 0x2018, 0x92 => 0x2019, 0x93 => 0x201C,
+          0x94 => 0x201D, 0x95 => 0x2022, 0x96 => 0x2013, 0x97 => 0x2014,
+          0x98 => 0x02DC, 0x99 => 0x2122, 0x9A => 0x0161, 0x9B => 0x203A,
+          0x9C => 0x0153, 0x9E => 0x017E, 0x9F => 0x0178
+        }.each { |b, cp| TABLE[b] = cp }
+        (0xA0..0xFF).each { |b| TABLE[b] = b }
+        TABLE.freeze
+      end
+    end
+  end
+end

data/lib/pdfrb/font/encoding/zapf_dingbats_encoding.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module Encoding
+      # ZapfDingbatsEncoding. Maps byte values to glyph names.
+      # Used by the 14th standard font (ZapfDingbats).
+      module ZapfDingbatsEncoding
+        TABLE = Array.new(256, 0x3F).freeze
+      end
+    end
+  end
+end