pdfrb 0.1.0

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      # Evaluates a predicate AST against a Context. Returns a Ruby
+      # value (typically Boolean for predicates; Integer/String for
+      # arithmetic helpers like ArrayLength, FileSize).
+      class Evaluator
+        attr_reader :context
+
+        def initialize(context)
+          @context = context
+        end
+
+        def self.call(ast, context)
+          new(context).evaluate(ast)
+        end
+
+        def evaluate(node)
+          return nil if node.nil?
+
+          case node
+          when AST::FunctionCall then dispatch_function(node)
+          when AST::AtKey then resolve_at_key(node.name)
+          when AST::PathExpr then resolve_path(node.segments)
+          when AST::Literal then node.value
+          when AST::ArrayLit then node.values
+          when AST::BinOp then eval_binop(node)
+          when AST::UnaryOp then eval_unaryop(node)
+          when AST::LogicalOp then eval_logical(node)
+          else
+            raise Pdfrb::Error, "unknown AST node #{node.class}"
+          end
+        end
+
+        private
+
+        def dispatch_function(node)
+          name = node.name.sub("fn:", "")
+          fn = Functions.registry[name]
+          if fn.nil?
+            raise Pdfrb::ValidationError.new(
+              "unknown predicate function fn:#{name}",
+              predicate_name: "fn:#{name}"
+            )
+          end
+
+          args = node.args.map { |a| evaluate(a) }
+          fn.call(args, context)
+        end
+
+        def resolve_at_key(name)
+          return nil unless context.current
+
+          context.current[name.to_sym]
+        end
+
+        def resolve_path(segments)
+          case segments.first
+          when "parent" then walk(context.parent, segments[1..])
+          when "trailer" then walk(context.trailer, segments[1..])
+          else
+            walk(context.current, segments)
+          end
+        end
+
+        def walk(start, segments)
+          cur = start
+          segments.each do |seg|
+            return nil unless cur.respond_to?(:[])
+            next if seg.nil?
+
+            cur = cur[seg.to_sym]
+          end
+          cur
+        end
+
+        def eval_binop(node)
+          left = evaluate(node.left)
+          right = evaluate(node.right)
+          case node.op
+          when :== then left == right
+          when :"!=" then left != right
+          when :< then left.to_f < right.to_f
+          when :> then left.to_f > right.to_f
+          when :<= then left.to_f <= right.to_f
+          when :>= then left.to_f >= right.to_f
+          when :+ then left.to_f + right.to_f
+          when :- then left.to_f - right.to_f
+          when :* then left.to_f * right.to_f
+          when :/ then left.to_f / right.to_f
+          when :% then left.to_i % right.to_i
+          end
+        end
+
+        def eval_unaryop(node)
+          case node.op
+          when :! then !evaluate(node.operand)
+          end
+        end
+
+        def eval_logical(node)
+          left = evaluate(node.left)
+          case node.op
+          when :"&&" then left && evaluate(node.right)
+          when :"||" then left || evaluate(node.right)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/arlington/predicate/functions/arithmetic.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      module Functions
+        # Arithmetic helpers: ArrayLength, StringLength, RequiredValue,
+        # BitSet, BitsClear, BitsSet, KeyNameIsColorant.
+        module ArithmeticPredicates
+          module_function
+
+          def register_all
+            Functions.register("ArrayLength") do |args, ctx|
+              key = args.first
+              val = ctx.current && ctx.current[key.to_sym]
+              val = val.to_a if val.is_a?(Pdfrb::Model::PdfArray)
+              val.is_a?(::Array) ? val.length : 0
+            end
+
+            Functions.register("StringLength") do |args, ctx|
+              key = args.first
+              val = ctx.current && ctx.current[key.to_sym]
+              val.is_a?(::String) ? val.bytesize : 0
+            end
+
+            Functions.register("RequiredValue") do |_args, _ctx|
+              # Caller wraps as RequiredValue(@X == Y); the comparison
+              # happens in BinOp, this just passes through.
+              true
+            end
+
+            Functions.register("BitSet") do |args, _ctx|
+              value, bit = args
+              next false unless value.is_a?(::Integer) && bit.is_a?(::Integer)
+
+              (value & (1 << bit)).nonzero?
+            end
+
+            Functions.register("BitsClear") do |args, _ctx|
+              value, mask = args
+              next false unless value.is_a?(::Integer) && mask.is_a?(::Integer)
+
+              (value & mask).zero?
+            end
+
+            Functions.register("BitsSet") do |args, _ctx|
+              value, mask = args
+              next false unless value.is_a?(::Integer) && mask.is_a?(::Integer)
+
+              (value & mask) == mask
+            end
+
+            Functions.register("KeyNameIsColorant") do |_args, _ctx|
+              false # consumer-side; default to false
+            end
+
+            Functions.register("NoCycle") do |_args, _ctx|
+              true # consumer-side; assume no cycles until proven
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Pdfrb::Arlington::Predicate::Functions::ArithmeticPredicates.register_all

data/lib/pdfrb/arlington/predicate/functions/file.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      module Functions
+        # File-level helpers: FileSize.
+        module FilePredicates
+          module_function
+
+          def register_all
+            Functions.register("FileSize") do |_args, ctx|
+              ctx.file_size
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Pdfrb::Arlington::Predicate::Functions::FilePredicates.register_all

data/lib/pdfrb/arlington/predicate/functions/logical.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      module Functions
+        # Logical predicates that don't fit Ruby's native && / || / !
+        # dispatch: Eval (run a sub-expression), Not (alias for !).
+        module LogicalPredicates
+          module_function
+
+          def register_all
+            Functions.register("Eval") do |args, _ctx|
+              # Eval is special: its single argument is already
+              # evaluated by the time we get it (because the Evaluator
+              # walks args eagerly). So we just return the value as-is.
+              args.first
+            end
+
+            Functions.register("Not") do |args, _ctx|
+              !args.first
+            end
+
+            Functions.register("And") do |args, _ctx|
+              args.all? { |a| a }
+            end
+
+            Functions.register("Or") do |args, _ctx|
+              args.any? { |a| a }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Pdfrb::Arlington::Predicate::Functions::LogicalPredicates.register_all

data/lib/pdfrb/arlington/predicate/functions/presence.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      module Functions
+        # Presence predicates: IsRequired, IsPresent, NotPresent.
+        # These return Booleans.
+        module PresencePredicates
+          module_function
+
+          def register_all
+            Functions.register("IsRequired") do |args, ctx|
+              # If a single predicate arg, evaluate its truthiness.
+              # If no args, default to true.
+              args.empty? ? true : !!args.first
+            end
+
+            Functions.register("IsPresent") do |args, ctx|
+              next false if args.empty?
+
+              key = args.first
+              ctx.current && !ctx.current[key.to_sym].nil?
+            end
+
+            Functions.register("NotPresent") do |args, ctx|
+              next true if args.empty?
+
+              key = args.first
+              ctx.current.nil? || ctx.current[key.to_sym].nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Pdfrb::Arlington::Predicate::Functions::PresencePredicates.register_all

data/lib/pdfrb/arlington/predicate/functions/reference.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      module Functions
+        # Reference-shape predicates: MustBeDirect, MustBeIndirect.
+        # These are mostly used in the IndirectReference column of
+        # TSVs to override the TRUE/FALSE default.
+        module ReferencePredicates
+          module_function
+
+          def register_all
+            Functions.register("MustBeDirect") do |_args, _ctx|
+              true # semantically: the field must be a direct object
+            end
+
+            Functions.register("MustBeIndirect") do |_args, _ctx|
+              true # semantically: the field must be an indirect object
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Pdfrb::Arlington::Predicate::Functions::ReferencePredicates.register_all

data/lib/pdfrb/arlington/predicate/functions/version.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      module Functions
+        # Version predicates: SinceVersion, BeforeVersion, Deprecated,
+        # IsPDFVersion, Extension.
+        module VersionPredicates
+          module_function
+
+          def register_all
+            Functions.register("SinceVersion") do |args, ctx|
+              ver = args.first
+              next false unless ver.is_a?(Pdfrb::Arlington::PdfVersion)
+
+              ctx.version >= ver
+            end
+
+            Functions.register("BeforeVersion") do |args, ctx|
+              ver = args.first
+              next false unless ver.is_a?(Pdfrb::Arlington::PdfVersion)
+
+              ctx.version < ver
+            end
+
+            Functions.register("Deprecated") do |args, ctx|
+              ver = args.first
+              next false unless ver.is_a?(Pdfrb::Arlington::PdfVersion)
+
+              ctx.version >= ver
+            end
+
+            Functions.register("IsPDFVersion") do |args, ctx|
+              ver = args.first
+              next false unless ver.is_a?(Pdfrb::Arlington::PdfVersion)
+
+              ctx.version == ver
+            end
+
+            Functions.register("Extension") do |_args, _ctx|
+              # Whether a named extension applies is document-specific;
+              # default false (consumer can override via Document config).
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Pdfrb::Arlington::Predicate::Functions::VersionPredicates.register_all

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      # Registry of `fn:Name` predicate implementations. Each module
+      # under Functions implements one or more predicates and
+      # registers them on load via `register`.
+      module Functions
+        @registry = {}
+
+        class << self
+          attr_reader :registry
+
+          def register(name, &block)
+            @registry[name.to_s] = block
+          end
+
+          def clear!
+            @registry.clear
+          end
+        end
+      end
+    end
+  end
+end
+
+# Load built-in function groups. Each calls Functions.register on load.
+require "pdfrb/arlington/predicate/functions/version"
+require "pdfrb/arlington/predicate/functions/presence"
+require "pdfrb/arlington/predicate/functions/logical"
+require "pdfrb/arlington/predicate/functions/arithmetic"
+require "pdfrb/arlington/predicate/functions/reference"
+require "pdfrb/arlington/predicate/functions/file"

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Arlington
+    module Predicate
+      # Tokenises the predicate mini-DSL.
+      #
+      #   fn:IsRequired(@Foo==Bar && fn:SinceVersion(2.0))
+      #
+      # Produces a stream of Token values: `[:fn_call, "fn:IsRequired"]`,
+      # `[:lparen]`, `[:at_key, "Foo"]`, `[:op, "=="]`, `[:name, "Bar"]`,
+      # `[:logic_and]`, `[:fn_call, "fn:SinceVersion"]`, `[:lparen]`,
+      # `[:version, "2.0"]`, `[:rparen]`, `[:rparen]`.
+      class Lexer
+        attr_reader :source, :tokens
+
+        def initialize(source)
+          @source = source.to_s
+          @tokens = []
+          @pos = 0
+        end
+
+        def self.tokenize(source)
+          new(source).tokenize
+        end
+
+        def tokenize
+          while @pos < @source.length
+            ch = peek
+            if ch =~ /\s/
+              advance
+            elsif start_fn_call?
+              scan_fn_call
+            elsif ch == "@"
+              scan_at_key
+            elsif ch =~ /[0-9]/
+              scan_number
+            elsif ch == "'"
+              scan_quoted_string
+            elsif ch == "["
+              scan_array
+            elsif ch =~ /[A-Za-z_]/
+              scan_name_or_path
+            elsif start_two_char_op?
+              scan_two_char_op
+            elsif ch =~ /[!()<>,&|*+\-\/%=]/
+              scan_single_char
+            else
+              raise Pdfrb::LexError,
+                    "predicate lexer: unexpected char #{ch.inspect} at pos #{@pos}"
+            end
+          end
+          @tokens.freeze
+        end
+
+        private
+
+        def peek(offset = 0)
+          @source[@pos + offset]
+        end
+
+        def advance(n = 1)
+          tok = @source[@pos, n]
+          @pos += n
+          tok
+        end
+
+        def start_fn_call?
+          @source[@pos, 3] == "fn:" &&
+            @source[@pos + 3, 1] =~ /[A-Z]/
+        end
+
+        def scan_fn_call
+          advance(3) # consume fn:
+          name = +""
+          while @pos < @source.length && peek =~ /[A-Za-z0-9_]/
+            name << advance
+          end
+          @tokens << [:fn_call, "fn:#{name}"]
+        end
+
+        def scan_at_key
+          advance # consume @
+          name = +""
+          while @pos < @source.length && peek =~ /[A-Za-z0-9_]/
+            name << advance
+          end
+          @tokens << [:at_key, name.to_s]
+        end
+
+        def scan_number
+          num = +""
+          while @pos < @source.length && peek =~ /[0-9eE.+\-]/
+            num << advance
+          end
+          @tokens << [:number, num.to_s]
+        end
+
+        def scan_quoted_string
+          advance # consume '
+          body = +""
+          while @pos < @source.length && peek != "'"
+            body << advance
+          end
+          advance # consume closing '
+          @tokens << [:string, body.to_s]
+        end
+
+        def scan_array
+          advance # consume [
+          body = +""
+          depth = 1
+          while @pos < @source.length && depth.positive?
+            ch = advance
+            if ch == "["
+              depth += 1
+              body << ch
+            elsif ch == "]"
+              depth -= 1
+              body << ch if depth.positive?
+            else
+              body << ch
+            end
+          end
+          @tokens << [:array, body.to_s.strip]
+        end
+
+        def scan_name_or_path
+          name = +""
+          while @pos < @source.length && peek =~ /[A-Za-z0-9_:]/
+            name << advance
+          end
+          if name.include?("::")
+            @tokens << [:path, name.to_s]
+          else
+            @tokens << [:name, name.to_s]
+          end
+        end
+
+        def start_two_char_op?
+          two = @source[@pos, 2]
+          %w[== != <= >= && ||].include?(two)
+        end
+
+        def scan_two_char_op
+          tok = advance(2)
+          case tok
+          when "==" then @tokens << [:op, :==]
+          when "!=" then @tokens << [:op, :"!="]
+          when "<=" then @tokens << [:op, :<=]
+          when ">=" then @tokens << [:op, :>=]
+          when "&&" then @tokens << [:logic_and]
+          when "||" then @tokens << [:logic_or]
+          end
+        end
+
+        def scan_single_char
+          ch = advance
+          case ch
+          when "(" then @tokens << [:lparen]
+          when ")" then @tokens << [:rparen]
+          when "," then @tokens << [:comma]
+          when "<" then @tokens << [:op, :<]
+          when ">" then @tokens << [:op, :>]
+          when "!" then @tokens << [:unary_not]
+          when "+" then @tokens << [:op, :+]
+          when "-" then @tokens << [:op, :-]
+          when "*" then @tokens << [:op, :*]
+          when "/" then @tokens << [:op, :/]
+          when "%" then @tokens << [:op, :%]
+          when "=" then @tokens << [:op, :==]
+          end
+        end
+      end
+    end
+  end
+end