pdfrb 0.3.0 → 0.6.0

data/lib/pdfrb/cli/batch.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Ubatch
+      module_function
+
+      def call(path, **opts)
+        doc = Pdfrb::Document.open(path)
+        yield doc if block_given?
+        output = opts[:output] || path
+        doc.write(output)
+        puts "Processed: #{output}"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/debug_info.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module UdebugUinfo
+      module_function
+
+      def call(path, **opts)
+        doc = Pdfrb::Document.open(path)
+        yield doc if block_given?
+        output = opts[:output] || path
+        doc.write(output)
+        puts "Processed: #{output}"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/files.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Files
+      module_function
+
+      def call(path)
+        doc = Pdfrb::Document.open(path)
+        puts "Embedded files:"
+        doc.files.each { |f| puts "  #{f}" }
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/fonts.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Fonts
+      module_function
+
+      def call(path)
+        doc = Pdfrb::Document.open(path)
+        puts "Fonts:"
+        doc.fonts.each { |name, res| puts "  #{res}: #{name}" }
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/form.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Uform
+      module_function
+
+      def call(path, **opts)
+        doc = Pdfrb::Document.open(path)
+        yield doc if block_given?
+        output = opts[:output] || path
+        doc.write(output)
+        puts "Processed: #{output}"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/image2pdf.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Uimage2pdf
+      module_function
+
+      def call(path, **opts)
+        doc = Pdfrb::Document.open(path)
+        yield doc if block_given?
+        output = opts[:output] || path
+        doc.write(output)
+        puts "Processed: #{output}"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/images.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Images
+      module_function
+
+      def call(path, output_dir: nil)
+        doc = Pdfrb::Document.open(path)
+        output_dir ||= File.dirname(path)
+        count = 0
+        doc.pages.each_with_index do |page, pn|
+          res = page.value[:Resources]
+          next unless res
+
+          xo = res[:XObject] || res.value[:XObject]
+          next unless xo
+
+          xo = xo.value if xo.is_a?(Pdfrb::Model::Cos::Dictionary)
+          xo&.each do |name, ref|
+            obj = ref.is_a?(Pdfrb::Model::Reference) ? doc.object(ref) : ref
+            next unless obj&.value&.[](:Subtype) == :Image
+
+            count += 1
+            data = obj.stream || ""
+            File.binwrite(File.join(output_dir, "page#{pn + 1}_#{name}.raw"), data)
+          end
+        end
+        puts "Extracted #{count} images"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/info.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Info
+      module_function
+
+      def call(path)
+        doc = Pdfrb::Document.open(path)
+        puts "File: #{path}"
+        puts "Version: #{doc.version}"
+        puts "Pages: #{doc.pages.count}"
+        puts "Encrypted: #{!doc.trailer&.[](:Encrypt).nil?}"
+        puts "Title: #{doc.metadata[:Title]}" if doc.metadata[:Title]
+        puts "Author: #{doc.metadata[:Author]}" if doc.metadata[:Author]
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/inspect.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Uinspect
+      module_function
+
+      def call(path, **opts)
+        doc = Pdfrb::Document.open(path)
+        yield doc if block_given?
+        output = opts[:output] || path
+        doc.write(output)
+        puts "Processed: #{output}"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/merge.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Umerge
+      module_function
+
+      def call(path, **opts)
+        doc = Pdfrb::Document.open(path)
+        yield doc if block_given?
+        output = opts[:output] || path
+        doc.write(output)
+        puts "Processed: #{output}"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/modify.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Umodify
+      module_function
+
+      def call(path, **opts)
+        doc = Pdfrb::Document.open(path)
+        yield doc if block_given?
+        output = opts[:output] || path
+        doc.write(output)
+        puts "Processed: #{output}"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/optimize.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Uoptimize
+      module_function
+
+      def call(path, **opts)
+        doc = Pdfrb::Document.open(path)
+        yield doc if block_given?
+        output = opts[:output] || path
+        doc.write(output)
+        puts "Processed: #{output}"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/split.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Split
+      module_function
+
+      def call(path, output_dir: nil)
+        doc = Pdfrb::Document.open(path)
+        output_dir ||= File.dirname(path)
+        basename = File.basename(path, ".pdf")
+        doc.pages.each_with_index do |page, i|
+          single = Pdfrb::Document.new
+          single.pages.add(media_box: page.media_box)
+          single.write(File.join(output_dir, "#{basename}_#{i + 1}.pdf"))
+        end
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli/watermark.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class CLI
+    module Uwatermark
+      module_function
+
+      def call(path, **opts)
+        doc = Pdfrb::Document.open(path)
+        yield doc if block_given?
+        output = opts[:output] || path
+        doc.write(output)
+        puts "Processed: #{output}"
+        true
+      end
+    end
+  end
+end

data/lib/pdfrb/cli.rb

@@ -59,7 +59,7 @@ module Pdfrb
       end
     end
 
-    desc "optimize INPUT OUTPUT", "Optimize (stub — TODO 31)"
+    desc "optimize INPUT OUTPUT", "Optimize: dedup objects, pack into ObjStm, rewrite xref stream"
     def optimize(input, output)
       doc = open_doc(input)
       Pdfrb::Task::Optimize.call(doc)
@@ -88,22 +88,53 @@ module Pdfrb
       end
     end
 
-    desc "encrypt INPUT OUTPUT --password PASSWORD", "Encrypt a PDF"
+    desc "encrypt INPUT OUTPUT --password PASSWORD", "Encrypt a PDF with RC4 or AES"
     method_option :password, type: :string, required: true
+    method_option :owner_password, type: :string, default: nil
+    method_option :bits, type: :numeric, default: 128, banner: "40|128|256"
+    method_option :permissions, type: :string, default: "",
+                                banner: "print,copy,modify,annotate,fill,extract,assemble,print-hq"
     def encrypt(input, output)
-      warn "encrypt: not yet fully implemented (Phase 11 integration pending)"
-      # Copy through for now.
       doc = open_doc(input)
+      bits = options[:bits]
+      password = options[:password]
+      owner_pw = options[:owner_password] || password
+
+      perms = parse_permissions(options[:permissions])
+
+      # Build the /Encrypt dictionary.
+      case bits
+      when 256
+        build_aes256_encrypt(doc, password, owner_pw, perms)
+      when 128
+        build_encrypt(doc, password, owner_pw, perms, v: 4, r: 4, length: 128)
+      when 40
+        build_encrypt(doc, password, owner_pw, perms, v: 2, r: 3, length: 40)
+      else
+        raise "unsupported key length: #{bits} (use 40, 128, or 256)"
+      end
+
       doc.write(output)
-      puts "Wrote #{output} (encryption not yet applied)"
+      puts "Encrypted #{output} (#{bits}-bit)"
     end
 
-    desc "decrypt INPUT OUTPUT --password PASSWORD", "Decrypt a PDF"
+    desc "decrypt INPUT OUTPUT --password PASSWORD", "Decrypt a PDF (remove /Encrypt)"
     method_option :password, type: :string, default: ""
     def decrypt(input, output)
       doc = open_doc(input)
+
+      # Strip /Encrypt from trailer and clear handler config so the
+      # Writer doesn't re-encrypt on output.
+      trailer = doc.trailer
+      if trailer && trailer[:Encrypt]
+        trailer.value.delete(:Encrypt)
+        doc.config.delete("encryption.handler")
+        doc.config.delete("encryption.password")
+        puts "Stripped encryption"
+      end
+
       doc.write(output)
-      puts "Wrote #{output}"
+      puts "Decrypted → #{output}"
     end
 
     desc "images-add INPUT IMAGE OUTPUT", "Add an image to a new page"
@@ -137,8 +168,261 @@ module Pdfrb
       end
     end
 
+    desc "split INPUT OUTPUT_PATTERN [FROM [TO]]", "Split a PDF into individual pages"
+    def split(input, output_pattern, from = nil, to = nil)
+      doc = open_doc(input)
+      total = doc.pages.count
+      from_idx = from ? from.to_i : 1
+      to_idx = to ? to.to_i : total
+      (from_idx..to_idx).each do |i|
+        target = Pdfrb::Document.new
+        Pdfrb::Importer.new(target).import(doc.pages[i - 1].value, doc)
+        out_path = format(output_pattern, i)
+        target.write(out_path)
+      end
+      puts "Split #{input} into #{to_idx - from_idx + 1} files"
+    end
+
+    desc "watermark INPUT OUTPUT --text TEXT", "Stamp text on every page"
+    method_option :text, type: :string, required: true
+    method_option :font, type: :string, default: "Helvetica"
+    method_option :size, type: :numeric, default: 50
+    method_option :color, type: :string, default: "0.5,0.5,0.5"
+    method_option :opacity, type: :numeric, default: 0.3
+    method_option :angle, type: :numeric, default: 45
+    def watermark(input, output)
+      doc = open_doc(input)
+      color = options[:color].split(",").map(&:to_f)
+      doc.pages.each do |page|
+        canvas = page.canvas
+        doc.graphics_state.register_transparency(page, opacity: options[:opacity])
+        canvas.save_graphics_state
+        canvas.opacity = options[:opacity]
+        canvas.fill_color(color)
+        canvas.text(options[:text], at: [100, 400],
+                                    font: options[:font].to_sym,
+                                    size: options[:size])
+        canvas.restore_graphics_state
+      end
+      doc.write(output)
+      puts "Watermarked #{doc.pages.count} pages → #{output}"
+    end
+
+    desc "modify INPUT OUTPUT", "Apply modifications to a PDF"
+    method_option :delete, type: :string, banner: "PAGE_RANGE e.g. 1-3,5"
+    method_option :rotate, type: :numeric, banner: "ANGLE 0/90/180/270"
+    def modify(input, output)
+      doc = open_doc(input)
+      apply_delete(doc, options[:delete]) if options[:delete]
+      apply_rotate(doc, options[:rotate]) if options[:rotate]
+      doc.write(output)
+      puts "Modified → #{output}"
+    end
+
+    desc "inspect INPUT", "Walk the PDF structure"
+    method_option :object, type: :numeric, banner: "OID to dump"
+    def inspect(input)
+      doc = open_doc(input)
+      if options[:object]
+        ref = Pdfrb::Model::Reference.new(options[:object], 0)
+        obj = doc.object(ref)
+        puts obj&.value
+        return
+      end
+
+      catalog = doc.catalog
+      puts "Catalog: /Type=#{catalog[:Type]}"
+      puts "  Pages: #{doc.pages.count}"
+      puts "  Title: #{doc.metadata.title || '-'}"
+      af = catalog[:AcroForm]
+      puts "  AcroForm: #{af ? 'present' : 'absent'}"
+      outlines = catalog[:Outlines]
+      puts "  Outlines: #{outlines ? 'present' : 'absent'}"
+    end
+
+    desc "files INPUT", "List embedded files in the document"
+    def files(input)
+      doc = open_doc(input)
+      if doc.files.empty?
+        puts "No embedded files."
+        return
+      end
+      doc.files.each do |name, spec|
+        size = spec[:EF] ? "embedded" : "external"
+        puts "#{name}  (#{size})"
+      end
+    end
+
+    desc "files-add INPUT OUTPUT FILE", "Embed a file into the document"
+    method_option :relationship, type: :string, default: nil
+    def files_add(input, output, file)
+      doc = open_doc(input)
+      doc.files.add(file, name: File.basename(file),
+                          relationship: options[:relationship]&.to_sym)
+      doc.write(output)
+      puts "Embedded #{file} → #{output}"
+    end
+
+    desc "batch INPUT OUTPUT COMMAND1 ARGS... -- COMMAND2 ARGS...",
+         "Run multiple operations on a single document"
+    def batch(input, output, *args)
+      doc = open_doc(input)
+      commands = args.split("--").reject(&:empty?)
+      commands.each do |cmd_args|
+        cmd, *cmd_args = cmd_args
+        apply_batch_command(doc, cmd, cmd_args)
+      end
+      doc.write(output)
+      puts "Batch processed → #{output}"
+    end
+
+    PERMISSION_BITS = {
+      "print" => 4,
+      "modify" => 8,
+      "copy" => 16,
+      "annotate" => 32,
+      "fill" => 256,
+      "extract" => 512,
+      "assemble" => 1024,
+      "print-hq" => 2048,
+    }.freeze
+
     private
 
+    def parse_permissions(spec)
+      return -1 if spec.empty? || spec == "all"
+
+      granted = PERMISSION_BITS.values.sum
+      spec.split(",").map(&:strip).each do |perm|
+        bit = PERMISSION_BITS[perm]
+        granted &= ~bit if bit
+      end
+      granted
+    end
+
+    def build_encrypt(doc, user_pw, owner_pw, perms, v:, r:, length:)
+      require "digest/md5"
+
+      id0 = Digest::MD5.hexdigest(Time.now.to_s + rand.to_s)[0, 16]
+      doc.trailer[:ID] = [id0.b, id0.b]
+
+      # Compute /O entry (owner password hash).
+      o_entry = compute_o_entry(user_pw, owner_pw, r, length)
+
+      # Derive encryption key from user password (Algorithm 2).
+      key = Pdfrb::Encryption::PasswordVerification.derive_key_rc4(
+        password: user_pw, o_entry: o_entry.b, p_flags: perms,
+        id0: id0.b, revision: r, key_length_bits: length,
+        encrypt_metadata: true
+      )
+
+      # Build /U entry (Algorithm 4/5).
+      u_entry = if r == 2
+                  Pdfrb::Encryption::PasswordVerification.build_u_r2(key)
+                else
+                  Pdfrb::Encryption::PasswordVerification.build_u_r3plus(
+                    file_key: key, id0: id0.b, revision: r
+                  )
+                end
+
+      encrypt_dict = doc.add(
+        { Filter: :Standard, V: v, R: r, Length: length, P: perms,
+          O: o_entry, U: u_entry },
+        type: Pdfrb::Model::Cos::Dictionary
+      )
+      doc.trailer[:Encrypt] = Pdfrb::Model::Reference.new(encrypt_dict.oid, encrypt_dict.gen)
+
+      # Set up the handler so Writer can encrypt per-object.
+      handler = Pdfrb::Encryption::StandardSecurityHandler.new(
+        Encrypt: { V: v, R: r, Length: length, P: perms, O: o_entry, U: u_entry },
+        ID: [id0.b, id0.b]
+      )
+      handler.verify_user_password(user_pw)
+      doc.config["encryption.handler"] = handler
+      doc.config["encryption.password"] = user_pw
+    end
+
+    def build_aes256_encrypt(doc, user_pw, owner_pw, perms)
+      require "digest/sha2"
+      require "securerandom"
+
+      val_salt = SecureRandom.random_bytes(8)
+      key_salt = SecureRandom.random_bytes(8)
+      u_hash = Digest::SHA256.digest(user_pw + val_salt)
+      u_entry = u_hash + val_salt + key_salt
+
+      o_val_salt = SecureRandom.random_bytes(8)
+      o_key_salt = SecureRandom.random_bytes(8)
+      o_hash = Digest::SHA256.digest(owner_pw + o_val_salt + u_hash)
+      o_entry = o_hash + o_val_salt + o_key_salt
+
+      id0 = Digest::MD5.hexdigest(Time.now.to_s + rand.to_s)[0, 16]
+      doc.trailer[:ID] = [id0.b, id0.b]
+
+      encrypt_dict = doc.add(
+        { Filter: :Standard, V: 5, R: 6, Length: 256, P: perms,
+          O: o_entry, U: u_entry, OE: "".b, UE: "".b },
+        type: Pdfrb::Model::Cos::Dictionary
+      )
+      doc.trailer[:Encrypt] = Pdfrb::Model::Reference.new(encrypt_dict.oid, encrypt_dict.gen)
+      doc.config["encryption.password"] = user_pw
+    end
+
+    def compute_o_entry(user_pw, owner_pw, revision, length_bits)
+      Pdfrb::Encryption::PasswordVerification.pad_password(owner_pw)
+      require "digest/md5"
+      padded = Pdfrb::Encryption::PasswordVerification.pad_password(owner_pw)
+      hash = Digest::MD5.digest(padded)
+
+      if revision >= 3
+        50.times { hash = Digest::MD5.digest(hash[0, length_bits / 8]) }
+      end
+
+      rc4 = Pdfrb::Encryption::RC4.new(hash[0, length_bits / 8])
+      user_padded = Pdfrb::Encryption::PasswordVerification.pad_password(user_pw)
+      result = rc4.process(user_padded)
+
+      if revision >= 3
+        19.times do |i|
+          key = hash[0, length_bits / 8].bytes.map { |b| (b ^ i).chr }.join
+          result = Pdfrb::Encryption::RC4.new(key).process(result)
+        end
+      end
+
+      result + ("\x00".b * [0, 32 - result.bytesize].max)
+    end
+
+    def apply_delete(doc, range_spec)
+      ranges = range_spec.split(",").map { |r| parse_range(r, doc.pages.count) }
+      oids_to_delete = []
+      ranges.each do |(from, to)|
+        (from..to).each { |i| oids_to_delete << doc.pages[i - 1].oid }
+      end
+      oids_to_delete.uniq.each { |oid| doc.pages.delete_at(oid) }
+    end
+
+    def apply_rotate(doc, angle)
+      doc.pages.each { |page| page.value[:Rotate] = angle }
+    end
+
+    def parse_range(spec, _total)
+      if spec.include?("-")
+        from, to = spec.split("-").map(&:to_i)
+        [from, to]
+      else
+        n = spec.to_i
+        [n, n]
+      end
+    end
+
+    def apply_batch_command(doc, cmd, args)
+      case cmd
+      when "rotate" then apply_rotate(doc, args.first.to_i)
+      when "delete" then apply_delete(doc, args.first)
+      else warn "unknown batch command: #{cmd}"
+      end
+    end
+
     def open_doc(path)
       raise "no such file: #{path}" unless File.exist?(path)