pdfrb 0.1.0

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      # Recursive-descent parser. Builds AST from tokens. Per the
+      # Arlington grammar: `&&` and `||` must be fully parenthesised
+      # (no precedence); we enforce that by only accepting them inside
+      # `(...)` groups.
+      class Parser
+        attr_reader :tokens, :ast
+
+        def initialize(tokens)
+          @tokens = tokens
+          @pos = 0
+        end
+
+        def self.parse(tokens_or_source)
+          toks = tokens_or_source.is_a?(::String) ? Lexer.tokenize(tokens_or_source) : tokens_or_source
+          new(toks).parse
+        end
+
+        def parse
+          return nil if tokens.empty?
+
+          node = parse_expr
+          raise Pdfrb::SyntaxError, "trailing tokens at pos #{@pos}" unless eof?
+
+          node
+        end
+
+        private
+
+        def peek(offset = 0)
+          tokens[@pos + offset]
+        end
+
+        def advance
+          tok = tokens[@pos]
+          @pos += 1
+          tok
+        end
+
+        def eof?
+          @pos >= tokens.length
+        end
+
+        def expect(type)
+          tok = advance
+          unless tok&.first == type
+            raise Pdfrb::SyntaxError,
+                  "expected #{type}, got #{tok.inspect} at pos #{@pos}"
+          end
+
+          tok
+        end
+
+        def parse_expr
+          tok = peek
+          return nil unless tok
+
+          case tok.first
+          when :lparen then parse_group
+          when :fn_call then parse_logical_continuation(parse_fn_call)
+          when :logic_and, :logic_or then parse_logical_continuation(parse_primary)
+          else
+            parse_logical_continuation(parse_comparison)
+          end
+        end
+
+        def parse_group
+          expect(:lparen)
+          node = parse_expr
+          expect(:rparen)
+          node
+        end
+
+        def parse_fn_call
+          name = advance.last
+          expect(:lparen)
+          args = parse_arg_list
+          expect(:rparen)
+          AST::FunctionCall.new(name: name, args: args)
+        end
+
+        def parse_arg_list
+          args = []
+          return args if peek&.first == :rparen
+
+          loop do
+            args << parse_expr
+            break unless peek&.first == :comma
+
+            advance
+          end
+          args
+        end
+
+        def parse_comparison
+          left = parse_primary
+          while peek&.first == :op && %i[== :!= :< :> :<= :>=].include?(peek.last)
+            op = advance.last
+            right = parse_primary
+            left = AST::BinOp.new(op: op, left: left, right: right)
+          end
+          left
+        end
+
+        def parse_logical_continuation(left)
+          # Only used inside a parenthesised group; the top level
+          # rejects stray && / ||.
+          while %i[logic_and logic_or].include?(peek&.first)
+            op_tok = advance
+            op = op_tok.first == :logic_and ? :"&&" : :"||"
+            right = parse_comparison
+            left = AST::LogicalOp.new(op: op, left: left, right: right)
+          end
+          left
+        end
+
+        def parse_primary
+          tok = peek
+          return nil unless tok
+
+          case tok.first
+          when :at_key then AST::AtKey.new(name: advance.last)
+          when :path then AST::PathExpr.new(segments: advance.last.split("::"))
+          when :number then AST::Literal.new(value: coerce_number(advance.last))
+          when :string then AST::Literal.new(value: advance.last)
+          when :name
+            n = advance.last
+            AST::Literal.new(value: n.to_sym)
+          when :array then parse_array_literal(advance.last)
+          when :unary_not
+            advance
+            AST::UnaryOp.new(op: :!, operand: parse_primary)
+          when :lparen then parse_group
+          when :fn_call then parse_fn_call
+          when :logic_and, :logic_or then parse_logical_continuation(parse_primary)
+          else
+            raise Pdfrb::SyntaxError, "unexpected token #{tok.inspect} at pos #{@pos}"
+          end
+        end
+
+        def parse_array_literal(body)
+          # The lexer stripped outer [ ]; split on whitespace and
+          # parse each as a primary. For nested arrays (complex types),
+          # re-add brackets and re-tokenise.
+          inner = body.strip
+          return AST::ArrayLit.new(values: []) if inner.empty?
+
+          if inner.start_with?("[")
+            # Re-parse nested arrays by feeding back through the lexer.
+            values = inner.scan(/\[[^\]]+\]/).map do |sub|
+              sub_body = sub[1..-2]
+              AST::ArrayLit.new(values: sub_body.split(/\s+/).filter_map do |v|
+                v.match?(/\A-?\d/) ? coerce_number(v) : v.to_sym
+              end)
+            end
+            return AST::ArrayLit.new(values: values)
+          end
+
+          AST::ArrayLit.new(values: inner.split(/\s+/).filter_map do |v|
+            v.match?(/\A-?\d/) ? coerce_number(v) : v.to_sym
+          end)
+        end
+
+        def coerce_number(str)
+          return str.to_i if str.match?(/\A-?\d+\z/)
+
+          if (m = str.match(/\A(\d+)\.(\d+)\z/))
+            major = m[1].to_i
+            minor = m[2].to_i
+            return PdfVersion.new(str) if (major == 1 && (0..7).cover?(minor)) || (major == 2 && minor.zero?)
+
+            return str.to_f
+          end
+          return str.to_f if str.match?(/\A-?\d*\.\d+\z/) || str.match?(/\A-?\d+\.\d*\z/)
+
+          str
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/arlington/predicate.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    # Predicate grammar (one component of the TSV model). Each
+    # predicate is `fn:Name(args, ...)`. Predicates compose via
+    # `&&`, `||`, `!`. The grammar does NOT support operator
+    # precedence — every `&&`/`||` must be fully parenthesised.
+    module Predicate
+      autoload :Lexer, "pdfrb/arlington/predicate/lexer"
+      autoload :Parser, "pdfrb/arlington/predicate/parser"
+      autoload :AST, "pdfrb/arlington/predicate/ast"
+      autoload :Evaluator, "pdfrb/arlington/predicate/evaluator"
+      autoload :Context, "pdfrb/arlington/predicate/context"
+    end
+  end
+end
+
+# Eager-load the function registry so predicates are registered as
+# soon as the Predicate namespace is touched. (Functions.register is
+# called at the bottom of each functions/*.rb.)
+require "pdfrb/arlington/predicate/functions"

data/lib/pdfrb/arlington/type.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    # The 17 pre-defined Arlington types. Each is a Symbol so it can
+    # be used uniformly in TSV-derived metadata. Per INTERNAL_GRAMMAR.md
+    # and README.md of the upstream model.
+    module Type
+      ALL = %i[
+        array
+        bitmask
+        boolean
+        date
+        dictionary
+        integer
+        matrix
+        name
+        name-tree
+        null
+        number
+        number-tree
+        rectangle
+        stream
+        string
+        string-ascii
+        string-byte
+        string-text
+      ].freeze
+
+      STRING_VARIANTS = %i[string string-ascii string-byte string-text].freeze
+      NUMERIC_VARIANTS = %i[integer number bitmask].freeze
+      TREE_VARIANTS = %i[name-tree number-tree].freeze
+
+      module_function
+
+      def valid?(sym)
+        ALL.include?(sym)
+      end
+    end
+  end
+end

data/lib/pdfrb/arlington.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Arlington PDF Model integration layer. Loads the vendored TSVs
+  # from `data/pdfrb/arlington/<version>/*.tsv` and surfaces them as
+  # typed records (`ObjectDefinition` -> `FieldDefinition`).
+  #
+  # Drives the field metadata on every `Model::Type::*` class via
+  # `Dictionary.arlington_object "Name"`. Predicates (`fn:...`) are
+  # lexed/parsed/evaluated on demand by the predicate sub-namespace.
+  module Arlington
+    autoload :Type, "pdfrb/arlington/type"
+    autoload :PdfVersion, "pdfrb/arlington/pdf_version"
+    autoload :Loader, "pdfrb/arlington/loader"
+    autoload :ObjectDefinition, "pdfrb/arlington/object_definition"
+    autoload :FieldDefinition, "pdfrb/arlington/field_definition"
+    autoload :Predicate, "pdfrb/arlington/predicate"
+  end
+end

data/lib/pdfrb/cli.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "thor"
+require "pdfrb"
+
+module Pdfrb
+  # `pdfrb` executable. Thor-based CLI mirroring `pdftk`/`pdfinfo`
+  # ergonomics. Each subcommand wraps a +Task::*+ module or reads
+  # directly off the +Document+ facade.
+  class CLI < Thor
+    package_name "pdfrb"
+
+    desc "version", "Print the pdfrb version"
+    def version
+      puts "pdfrb #{Pdfrb::VERSION}"
+    end
+
+    desc "info INPUT", "Print document metadata, page count, encryption status"
+    def info(input)
+      doc = open_doc(input)
+      puts "File: #{input}"
+      puts "PDF version: #{doc.version}"
+      puts "Pages: #{doc.pages.count}"
+      puts "Title: #{doc.metadata.title || '-'}"
+      puts "Author: #{doc.metadata.author || '-'}"
+      puts "Subject: #{doc.metadata.subject || '-'}"
+      puts "Producer: #{doc.metadata.producer || '-'}"
+      puts "Encrypted: #{encrypted?(doc)}"
+    end
+
+    desc "merge OUTPUT INPUT...", "Merge multiple PDFs into OUTPUT (in order)"
+    def merge(output, *inputs)
+      raise ArgumentError, "merge needs at least one INPUT" if inputs.empty?
+
+      target = Pdfrb::Document.new
+      inputs.each { |i| Pdfrb::Task::Merge.call(target, open_doc(i)) }
+      target.write(output)
+      puts "Wrote #{output} (#{target.pages.count} pages)"
+    end
+
+    desc "extract-text INPUT [OUTPUT]", "Extract text from each page"
+    def extract_text(input, output = nil)
+      doc = open_doc(input)
+      texts = Pdfrb::Task::ExtractText.call(doc)
+      if output
+        File.write(output, texts.join("\n\n--- page break ---\n\n"))
+        puts "Wrote #{output}"
+      else
+        texts.each_with_index { |t, i| puts "--- page #{i + 1} ---"; puts t }
+      end
+    end
+
+    desc "images INPUT", "List image XObjects in the document"
+    def images(input)
+      doc = open_doc(input)
+      Pdfrb::Task::ExtractImages.call(doc) do |info|
+        puts "page #{info.page_index + 1} /#{info.name} " \
+             "#{info.width}x#{info.height} filter=#{info.filter.inspect}"
+      end
+    end
+
+    desc "optimize INPUT OUTPUT", "Optimize (stub — TODO 31)"
+    def optimize(input, output)
+      doc = open_doc(input)
+      Pdfrb::Task::Optimize.call(doc)
+      doc.write(output)
+      puts "Wrote #{output}"
+    end
+
+    desc "encrypt INPUT OUTPUT --password PASSWORD", "Encrypt a PDF (stub — needs Phase 11 integration)"
+    method_option :password, type: :string, required: true
+    def encrypt(input, output)
+      warn "encrypt: not yet fully implemented (Phase 11 integration pending)"
+      # Copy through for now.
+      doc = open_doc(input)
+      doc.write(output)
+      puts "Wrote #{output} (encryption not yet applied)"
+    end
+
+    desc "decrypt INPUT OUTPUT --password PASSWORD", "Decrypt a PDF"
+    method_option :password, type: :string, default: ""
+    def decrypt(input, output)
+      doc = open_doc(input)
+      doc.write(output)
+      puts "Wrote #{output}"
+    end
+
+    desc "images-add INPUT IMAGE OUTPUT", "Add an image to a new page"
+    def images_add(input, image, output)
+      doc = open_doc(input)
+      name = doc.images.add(image)
+      doc.pages.add # just adds a blank page for now
+      doc.write(output)
+      puts "Added image as /#{name} and wrote #{output}"
+    end
+
+    desc "form INPUT", "List AcroForm fields"
+    def form(input)
+      doc = open_doc(input)
+      acro = doc.catalog[:AcroForm]
+      if acro.nil?
+        puts "No AcroForm in this document."
+        return
+      end
+      fields = acro[:Fields]
+      return unless fields
+
+      fields.each do |ref|
+        field = ref.is_a?(Pdfrb::Model::Reference) ? doc.object(ref) : ref
+        next unless field
+
+        name = field[:T] || "(unnamed)"
+        type = field[:FT] || "?"
+        value = field[:V] || "-"
+        puts "/#{name}  type=#{type}  value=#{value}"
+      end
+    end
+
+    private
+
+    def open_doc(path)
+      raise "no such file: #{path}" unless File.exist?(path)
+
+      Pdfrb::Document.open(path)
+    rescue Pdfrb::Error => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    def encrypted?(doc)
+      trailer = doc.trailer
+      trailer ? !trailer[:Encrypt].nil? : false
+    end
+  end
+end

data/lib/pdfrb/configuration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Per-Document configuration. A frozen Hash-with-defaults that can be
+  # deep-merged with user overrides. Mirrors HexaPDF::Configuration in
+  # shape, but starts minimal — settings get added as features land.
+  class Configuration
+    DEFAULTS = {
+      # When true, malformed PDFs are recovered heuristically instead
+      # of raising MalformedPdfError. Production readers should keep
+      # this true; strict validators can flip it off.
+      "source.recover_malformed" => true,
+
+      # When true, an encrypted PDF is decrypted on open (using
+      # decryption_opts passed to Document.new). Disable for raw
+      # inspection of ciphertext.
+      "document.auto_decrypt" => true,
+
+      # Callback invoked when a string field has an invalid encoding.
+      # Default: replace with U+FFFD in UTF-8.
+      "document.on_invalid_string" => ->(str) { str.encode("UTF-8", invalid: :replace, undef: :replace) },
+
+      # When true, errors that Pdfrb can auto-correct are raised after
+      # all (so test runs catch corruption). Production readers flip
+      # this off.
+      "parser.on_correctable_error" => ->(_doc, _msg) { false },
+
+      # When true, Stream objects larger than writer.compress_min_size
+      # are emitted with /Filter /FlateDecode on write. Existing
+      # /Filter values are honoured (no double compression).
+      "writer.compress_streams" => false,
+      "writer.compress_min_size" => 256
+    }.freeze
+
+    attr_reader :settings
+
+    def initialize(overrides = {})
+      @settings = deep_merge(DEFAULTS.dup, overrides)
+      freeze
+    end
+
+    def [](key)
+      @settings[key]
+    end
+
+    def []=(key, value)
+      @settings[key] = value
+    end
+
+    private
+
+    def deep_merge(target, source)
+      source.each do |k, v|
+        target[k] =
+          if target[k].is_a?(Hash) && v.is_a?(Hash)
+            deep_merge(target[k], v)
+          else
+            v
+          end
+      end
+      target
+    end
+  end
+end

data/lib/pdfrb/conformance/pdf_a.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Conformance
+    # PDF/A-1/2/3 validation (ISO 19005). Checks a document against
+    # the subset constraints. Returns a +Result+ with per-rule verdicts.
+    module PdfA
+      Result = Struct.new(:level, :passed, :violations, keyword_init: true)
+      Violation = Struct.new(:rule, :message, :object, keyword_init: true)
+
+      module_function
+
+      def validate(document, level: :a2b)
+        violations = []
+        check_no_encryption(document, violations)
+        check_has_metadata(document, violations)
+        check_embedded_fonts(document, violations)
+        Result.new(
+          level: level,
+          passed: violations.empty?,
+          violations: violations
+        )
+      end
+
+      def check_no_encryption(document, violations)
+        return unless document.trailer && document.trailer[:Encrypt]
+
+        violations << Violation.new(
+          rule: "no-encryption",
+          message: "PDF/A prohibits encryption",
+          object: "trailer"
+        )
+      end
+      private_class_method :check_no_encryption
+
+      def check_has_metadata(document, violations)
+        return if document.catalog[:Metadata]
+
+        violations << Violation.new(
+          rule: "metadata-required",
+          message: "PDF/A requires /Catalog/Metadata XMP stream",
+          object: "Catalog"
+        )
+      end
+      private_class_method :check_has_metadata
+
+      def check_embedded_fonts(document, violations)
+        document.pages.each do |page|
+          resources = page.value[:Resources]
+          next unless resources
+
+          fonts = resources.is_a?(Pdfrb::Model::Cos::Dictionary) ?
+                    resources.value[:Font] : resources[:Font]
+          next unless fonts
+
+          fonts.each_value do |ref|
+            font = ref.is_a?(Pdfrb::Model::Reference) ?
+                     document.object(ref) : ref
+            next unless font
+
+            unless font[:FontDescriptor]
+              violations << Violation.new(
+                rule: "embedded-fonts",
+                message: "Font /#{font[:BaseFont]} missing FontDescriptor",
+                object: font[:BaseFont]
+              )
+            end
+          end
+        end
+      end
+      private_class_method :check_embedded_fonts
+    end
+  end
+end

data/lib/pdfrb/conformance/pdf_ua.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Conformance
+    # PDF/UA-1 validation (ISO 14289). Checks tagged PDF, reading
+    # order, alt text, etc. Per Tech Note 001, /ActualText required
+    # for /Figure elements; per Tech Note 002, /Reference elements
+    # must wrap link annotations.
+    module PdfUA
+      Result = Struct.new(:passed, :violations, keyword_init: true)
+      Violation = Struct.new(:rule, :message, :object, keyword_init: true)
+
+      module_function
+
+      def validate(document)
+        violations = []
+        check_has_struct_tree(document, violations)
+        check_tagged(document, violations)
+        Result.new(passed: violations.empty?, violations: violations)
+      end
+
+      def check_has_struct_tree(document, violations)
+        return if document.catalog[:StructTreeRoot]
+
+        violations << Violation.new(
+          rule: "struct-tree-required",
+          message: "PDF/UA requires /Catalog/StructTreeRoot",
+          object: "Catalog"
+        )
+      end
+      private_class_method :check_has_struct_tree
+
+      def check_tagged(document, violations)
+        mark = document.catalog[:MarkInfo]
+        return if mark && mark[:Marked] == true
+
+        violations << Violation.new(
+          rule: "marked-required",
+          message: "PDF/UA requires /MarkInfo /Marked true",
+          object: "Catalog"
+        )
+      end
+      private_class_method :check_tagged
+    end
+  end
+end

data/lib/pdfrb/conformance.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # PDF/A conformance checks (ISO 19005). Subset of constraints on
+  # top of ISO 32000-2: no JavaScript, no encryption (A-1), embedded
+  # fonts required, XMP metadata required, etc.
+  module Conformance
+    autoload :PdfA, "pdfrb/conformance/pdf_a"
+    autoload :PdfUA, "pdfrb/conformance/pdf_ua"
+  end
+end