pdfrb 0.1.0

data/data/pdfrb/zapfdingbats.txt

@@ -0,0 +1,226 @@
+# -----------------------------------------------------------
+# Copyright 2002, 2010, 2015 Adobe Systems Incorporated.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License. You may
+# obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0.html
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+# -----------------------------------------------------------
+# Modified for use with HexaPDF
+# -----------------------------------------------------------
+# Name:          ITC Zapf Dingbats Glyph List
+# Table version: 2.0
+# Date:          September 20, 2002
+# URL:           https://github.com/adobe-type-tools/agl-aglfn
+#
+# Format: two semicolon-delimited fields:
+#   (1) glyph name--upper/lowercase letters and digits
+#   (2) Unicode scalar value--four uppercase hexadecimal digits
+#
+a100;❞
+a101;❡
+a102;❢
+a103;❣
+a104;❤
+a105;✐
+a106;❥
+a107;❦
+a108;❧
+a109;♠
+a10;✡
+a110;♥
+a111;♦
+a112;♣
+a117;✉
+a118;✈
+a119;✇
+a11;☛
+a120;①
+a121;②
+a122;③
+a123;④
+a124;⑤
+a125;⑥
+a126;⑦
+a127;⑧
+a128;⑨
+a129;⑩
+a12;☞
+a130;❶
+a131;❷
+a132;❸
+a133;❹
+a134;❺
+a135;❻
+a136;❼
+a137;❽
+a138;❾
+a139;❿
+a13;✌
+a140;➀
+a141;➁
+a142;➂
+a143;➃
+a144;➄
+a145;➅
+a146;➆
+a147;➇
+a148;➈
+a149;➉
+a14;✍
+a150;➊
+a151;➋
+a152;➌
+a153;➍
+a154;➎
+a155;➏
+a156;➐
+a157;➑
+a158;➒
+a159;➓
+a15;✎
+a160;➔
+a161;→
+a162;➣
+a163;↔
+a164;↕
+a165;➙
+a166;➛
+a167;➜
+a168;➝
+a169;➞
+a16;✏
+a170;➟
+a171;➠
+a172;➡
+a173;➢
+a174;➤
+a175;➥
+a176;➦
+a177;➧
+a178;➨
+a179;➩
+a17;✑
+a180;➫
+a181;➭
+a182;➯
+a183;➲
+a184;➳
+a185;➵
+a186;➸
+a187;➺
+a188;➻
+a189;➼
+a18;✒
+a190;➽
+a191;➾
+a192;➚
+a193;➪
+a194;➶
+a195;➹
+a196;➘
+a197;➴
+a198;➷
+a199;➬
+a19;✓
+a1;✁
+a200;➮
+a201;➱
+a202;✃
+a203;❐
+a204;❒
+a205;❮
+a206;❰
+a20;✔
+a21;✕
+a22;✖
+a23;✗
+a24;✘
+a25;✙
+a26;✚
+a27;✛
+a28;✜
+a29;✢
+a2;✂
+a30;✣
+a31;✤
+a32;✥
+a33;✦
+a34;✧
+a35;★
+a36;✩
+a37;✪
+a38;✫
+a39;✬
+a3;✄
+a40;✭
+a41;✮
+a42;✯
+a43;✰
+a44;✱
+a45;✲
+a46;✳
+a47;✴
+a48;✵
+a49;✶
+a4;☎
+a50;✷
+a51;✸
+a52;✹
+a53;✺
+a54;✻
+a55;✼
+a56;✽
+a57;✾
+a58;✿
+a59;❀
+a5;✆
+a60;❁
+a61;❂
+a62;❃
+a63;❄
+a64;❅
+a65;❆
+a66;❇
+a67;❈
+a68;❉
+a69;❊
+a6;✝
+a70;❋
+a71;●
+a72;❍
+a73;■
+a74;❏
+a75;❑
+a76;▲
+a77;▼
+a78;◆
+a79;❖
+a7;✞
+a81;◗
+a82;❘
+a83;❙
+a84;❚
+a85;❯
+a86;❱
+a87;❲
+a88;❳
+a89;❨
+a8;✟
+a90;❩
+a91;❬
+a92;❭
+a93;❪
+a94;❫
+a95;❴
+a96;❵
+a97;❛
+a98;❜
+a99;❝
+a9;✠

data/exe/pdfrb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Resolve the gem's lib/ directory relative to this exe so the CLI
+# works whether or not the gem is installed.
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+
+require "pdfrb/cli"
+
+Pdfrb::CLI.start(ARGV)

data/lib/pdfrb/arlington/field_definition.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    # One row in an Arlington TSV (one field in a PDF object type).
+    #
+    # The 12 columns are exposed as typed attributes where possible;
+    # predicate-laden values (Required, SpecialCase, SinceVersion with
+    # fn:...) preserve their raw text for the predicate evaluator to
+    # consume lazily.
+    class FieldDefinition
+      attr_reader :key, :types_raw, :since_version, :deprecated_in,
+                  :required_literal, :indirect_reference, :inheritable,
+                  :default_value, :possible_values, :special_case,
+                  :link, :note
+
+      def initialize(key:, types_raw:, since_version:, deprecated_in:,
+                     required_literal:, indirect_reference:, inheritable:,
+                     default_value:, possible_values:, special_case:,
+                     link:, note:)
+        @key = key
+        @types_raw = types_raw
+        @since_version = since_version
+        @deprecated_in = deprecated_in
+        @required_literal = required_literal
+        @indirect_reference = indirect_reference
+        @inheritable = inheritable
+        @default_value = default_value
+        @possible_values = possible_values
+        @special_case = special_case
+        @link = link
+        @note = note
+        freeze
+      end
+
+      # Build a FieldDefinition from a 12-element Array of TSV cells.
+      def self.from_row(row)
+        raise ArgumentError, "TSV row needs 12 cells" unless row.length == 12
+
+        new(
+          key: row[0],
+          types_raw: row[1],
+          since_version: PdfVersion.from_tsv_cell(row[2]) || PdfVersion.new("1.0"),
+          deprecated_in: PdfVersion.from_tsv_cell(row[3]),
+          required_literal: parse_required(row[4]),
+          indirect_reference: row[5],
+          inheritable: parse_boolean(row[6]),
+          default_value: row[7]&.then { |s| s.empty? ? nil : s },
+          possible_values: row[8]&.then { |s| s.empty? ? nil : s },
+          special_case: row[9]&.then { |s| s.empty? ? nil : s },
+          link: row[10]&.then { |s| s.empty? ? nil : s },
+          note: row[11]
+        )
+      end
+
+      # The bare type symbols this field allows (predicate-laden types
+      # are dropped — caller resolves those via the predicate
+      # evaluator if needed).
+      def types
+        types_raw.split(";").filter_map do |raw|
+          stripped = raw.strip
+          stripped.to_sym if Type.valid?(stripped.to_sym)
+        end
+      end
+
+      def array?
+        types.include?(:array)
+      end
+
+      def dictionary?
+        types.include?(:dictionary)
+      end
+
+      def stream?
+        types.include?(:stream)
+      end
+
+      def name?
+        types.include?(:name)
+      end
+
+      def required?
+        required_literal == true
+      end
+
+      def required_predicate?
+        required_literal.is_a?(::String) && required_literal.start_with?("fn:")
+      end
+
+      def inheritable?
+        inheritable == true
+      end
+
+      def links
+        return [] if link.nil?
+
+        link.scan(/\[([^\[\]]+)\]/).flatten.map { |l| l.split(",").map(&:strip) }.flatten
+      end
+
+      def possible_value_list
+        return [] if possible_values.nil?
+
+        possible_values.scan(/\[([^\[\]]+)\]/).flatten.flat_map do |l|
+          l.split(",").map(&:strip)
+        end
+      end
+
+      class << self
+        private
+
+        def parse_required(cell)
+          return true if cell == "TRUE"
+          return false if cell == "FALSE"
+          return nil if cell.nil? || cell.empty?
+
+          cell
+        end
+
+        def parse_boolean(cell)
+          return true if cell == "TRUE"
+          return false if cell == "FALSE"
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/arlington/loader.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    # Reads vendored Arlington TSVs from `data/pdfrb/arlington/<version>/`.
+    # Parsed ObjectDefinitions are memoized per (name, version).
+    #
+    # Errors:
+    #   * Pdfrb::Error if the TSV file is missing.
+    #   * Pdfrb::ParseError if a row has the wrong column count.
+    module Loader
+      HEADER = %w[Key Type SinceVersion DeprecatedIn Required IndirectReference
+                  Inheritable DefaultValue PossibleValues SpecialCase Link Note].freeze
+      private_constant :HEADER
+
+      @cache = {}
+
+      class << self
+        # Returns the ObjectDefinition for +name+ (e.g. "Catalog"),
+        # reading and parsing the TSV the first time, then memoizing.
+        def object_definition(name, version: "latest")
+          cache_key = [version, name]
+          return @cache[cache_key] if @cache.key?(cache_key)
+
+          @cache[cache_key] = read_and_parse(name, version)
+        end
+
+        def clear_cache!
+          @cache.clear
+        end
+
+        # Enumerate the names of every object defined in +version+
+        # (without extensions). Useful for conformance sweeps.
+        def list_object_names(version: "latest")
+          dir = tsv_dir(version)
+          return [] unless Dir.exist?(dir)
+
+          Dir.children(dir).sort.filter_map do |f|
+            f.sub(/\.tsv\z/, "") if f.end_with?(".tsv")
+          end
+        end
+
+        private
+
+        def read_and_parse(name, version)
+          path = tsv_path(name, version)
+          raise Pdfrb::Error, "Arlington TSV not found: #{name} (#{version})" unless File.exist?(path)
+
+          rows = parse_tsv(File.binread(path))
+          ObjectDefinition.from_tsv(rows, name: name, version: version)
+        end
+
+        def tsv_dir(version)
+          File.join(Pdfrb::DataDir.root, "arlington", version)
+        end
+
+        def tsv_path(name, version)
+          File.join(tsv_dir(version), "#{name}.tsv")
+        end
+
+        def parse_tsv(text)
+          text.force_encoding(Encoding::UTF_8)
+          lines = text.each_line.map { |l| l.chomp("\n").chomp("\r") }
+          lines.shift # discard header row
+          lines.filter_map do |line|
+            next if line.strip.empty?
+
+            cells = line.split("\t", -1)
+            # Real-world TSVs occasionally drop trailing empty cells
+            # (e.g. missing Note column). Pad to 12; reject if longer.
+            if cells.length < 12
+              cells.fill("", cells.length...12)
+            elsif cells.length > 12
+              raise Pdfrb::ParseError,
+                    "Arlington row has #{cells.length} cells (expected 12): #{line.inspect}"
+            end
+
+            cells
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/arlington/object_definition.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    # One TSV file = one PDF object type definition. Holds the list
+    # of FieldDefinitions and provides lookup by key (with wildcard
+    # support for map-style objects).
+    class ObjectDefinition
+      attr_reader :name, :version, :fields
+
+      def initialize(name:, version: "latest", fields: [])
+        @name = name
+        @version = version
+        @fields = fields
+        freeze
+      end
+
+      def self.from_tsv(rows, name:, version:)
+        fields = rows.map { |row| FieldDefinition.from_row(row) }
+        new(name: name, version: version, fields: fields)
+      end
+
+      def each_field(&block)
+        @fields.each(&block)
+      end
+
+      def field_for(key)
+        @fields.find { |f| f.key == key.to_s }
+      end
+      alias [] field_for
+
+      def keys
+        @fields.map(&:key)
+      end
+
+      def has_wildcard?
+        @fields.any? { |f| f.key == "*" }
+      end
+
+      def map?
+        @fields.first&.key == "*"
+      end
+    end
+  end
+end

data/lib/pdfrb/arlington/pdf_version.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    # PDF version value object. Comparable by [major, minor]. Handles
+    # the 9 canonical versions (1.0..1.7, 2.0) plus predicate-wrapped
+    # variants (`fn:Extension(name, version)`, `fn:Eval(expr)`).
+    #
+    # For predicate-wrapped versions, the +literal+ is the version
+    # embedded in the predicate; +extensions+ captures the named
+    # extension(s) attached. Evaluator-side predicate handling decides
+    # whether an extension applies to a given document.
+    class PdfVersion
+      include Comparable
+
+      CANONICAL = %w[1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 2.0].freeze
+
+      attr_reader :major, :minor, :literal, :extensions
+
+      def initialize(version, extensions: [])
+        case version
+        when PdfVersion
+          @major = version.major
+          @minor = version.minor
+          @literal = version.literal
+          @extensions = version.extensions
+        when ::String
+          @literal = parse_literal(version)
+          @major, @minor = parse_major_minor(@literal)
+          @extensions = extensions
+        else
+          raise ArgumentError, "PdfVersion needs a String, got #{version.class}"
+        end
+        freeze
+      end
+
+      def self.latest; new("2.0"); end
+
+      # Parse a TSV cell. Tolerates:
+      #   "1.7"                          -> 1.7
+      #   "fn:Extension(ISO_19005_3,1.7)" -> 1.7 + extension ISO_19005_3
+      #   "fn:Eval(...)"                  -> latest (caller resolves via predicate)
+      def self.from_tsv_cell(str)
+        return nil if str.nil? || str.empty?
+
+        s = str.strip
+        case s
+        when /\A(\d+\.\d+)\z/
+          new(Regexp.last_match(1))
+        when /\Afn:Extension\(([^,]+),\s*(\d+\.\d+)\)\z/
+          new(Regexp.last_match(2), extensions: [Regexp.last_match(1)])
+        when /\Afn:Extension\(([^,)]+)\)\z/
+          # name-only extension (e.g. fn:Extension(OpenOffice)) — no version.
+          new("2.0", extensions: [Regexp.last_match(1)])
+        when /\Afn:Eval\(/, /\Afn:SinceVersion\(/, /\Afn:IsPDFVersion\(/
+          new("2.0", extensions: [:predicate]) # caller resolves via predicate
+        else
+          raise Pdfrb::ParseError, "unrecognised PDF version: #{str.inspect}"
+        end
+      end
+
+      def to_s
+        "#{@major}.#{@minor}"
+      end
+
+      def to_a
+        [@major, @minor]
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(PdfVersion)
+
+        to_a <=> other.to_a
+      end
+
+      def hash
+        to_a.hash
+      end
+
+      def eql?(other)
+        other.is_a?(PdfVersion) && to_a == other.to_a
+      end
+      alias == eql?
+
+      def since?(other)
+        self >= other
+      end
+
+      def before?(other)
+        self < other
+      end
+
+      def deprecated_at?(deprecated_in)
+        return false unless deprecated_in
+
+        self >= deprecated_in
+      end
+
+      def predicate_wrapped?
+        @extensions == [:predicate]
+      end
+
+      private
+
+      def parse_literal(str)
+        return str if str.match?(/\A\d+\.\d+\z/)
+
+        # Caller should use from_tsv_cell for predicate forms; we tolerate
+        # by returning a sensible default.
+        str.match?(/\A\d+(\.\d+)?\z/) ? str : "2.0"
+      end
+
+      def parse_major_minor(str)
+        m = str.match(/\A(\d+)\.(\d+)\z/)
+        raise ArgumentError, "bad version #{str.inspect}" unless m
+
+        [m[1].to_i, m[2].to_i]
+      end
+    end
+  end
+end

data/lib/pdfrb/arlington/predicate/ast.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      # AST node types for the predicate grammar. Each is a small
+      # immutable Struct-like class with the operands it carries.
+      module AST
+        FunctionCall = Struct.new(:name, :args, keyword_init: true)
+        AtKey = Struct.new(:name, keyword_init: true)             # @Foo
+        PathExpr = Struct.new(:segments, keyword_init: true)      # trailer::Catalog::Pages
+        Literal = Struct.new(:value, keyword_init: true)          # 42, "str", :Name
+        ArrayLit = Struct.new(:values, keyword_init: true)        # [a, b, c]
+        BinOp = Struct.new(:op, :left, :right, keyword_init: true) # ==, !=, <, >, <=, >=, +, -, *, /
+        UnaryOp = Struct.new(:op, :operand, keyword_init: true)    # !
+        LogicalOp = Struct.new(:op, :left, :right, keyword_init: true) # &&, ||
+        Placeholder = Struct.new(:text, keyword_init: true)        # raw, unsupported
+      end
+    end
+  end
+end

data/lib/pdfrb/arlington/predicate/context.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      # Runtime context for predicate evaluation. Carries the current
+      # object, the document version, the byte size of the source
+      # file, and references to the parent and trailer dictionaries
+      # for path expressions (`parent::Foo`, `trailer::Catalog`).
+      class Context
+        attr_reader :current, :version, :file_size, :parent, :trailer
+
+        def initialize(current:, version:, file_size: 0, parent: nil, trailer: nil)
+          @current = current
+          @version = version
+          @file_size = file_size.to_i
+          @parent = parent
+          @trailer = trailer
+          freeze
+        end
+      end
+    end
+  end
+end