fillform 0.1.0

data/lib/fillform/line_breaker.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Fillform
+  # Breaks a paragraph into lines like iText's BidiLine: the paragraph loses its trailing whitespace,
+  # a line ends after the last split character before the first character that does not fit, or
+  # before that character, and only the first line keeps its leading whitespace. Each line comes with
+  # the width left on it, computed in floats like iText does, which aligns it.
+  class LineBreaker
+    NO_PRINT = /[​-‏‪-‮]/
+    CJK = /[⺀-힟豈-﫿︰-﹏｡-ﾟ]/
+
+    Line = Struct.new(:chars, :width_left)
+
+    def self.whitespace?(char) = char <= " "
+
+    def self.blank?(char) = whitespace?(char) || NO_PRINT.match?(char)
+
+    def self.rstrip(chars)
+      last = chars.rindex { |char| !blank?(char) }
+      last ? chars[0..last] : []
+    end
+
+    def initialize(chars, width, &char_width)
+      @chars = self.class.rstrip(chars)
+      @width = Float32.f(width)
+      @char_width = char_width
+    end
+
+    def lines
+      return [Line.new([], 0.0)] if @chars.empty?
+
+      result = []
+      position = 0
+      while position < @chars.size
+        position += 1 while position.positive? && position < @chars.size && self.class.blank?(@chars[position])
+        break if position == @chars.size
+
+        line, position = next_line(position)
+        result << line
+      end
+      result
+    end
+
+    private
+
+    # The branches of BidiLine#processLine, with the width each one leaves.
+    def next_line(start)
+      fitting, last_split, left = scan(start)
+      return [Line.new(@chars[start..], left), @chars.size] if fitting == @chars.size
+      return [Line.new([@chars[start]], 0.0), start + 1] if fitting == start
+
+      last = last_visible(start, fitting - 1)
+      return [Line.new(@chars[start...fitting], left), fitting] if last < start
+      if last_split.nil? || last_split >= last
+        return [Line.new(@chars[start..last], f(left + width(last + 1, fitting - 1))), fitting]
+      end
+
+      split_last = last_visible(start, last_split)
+      split_last = last_split if split_last < start
+      [Line.new(@chars[start..split_last], f(@width - width(start, split_last))), last_split + 1]
+    end
+
+    # The index of the first character that does not fit, the last split character up to it, and the
+    # width left.
+    def scan(start)
+      left = @width
+      last_split = nil
+      index = start
+      while index < @chars.size
+        char = @chars[index]
+        unless NO_PRINT.match?(char)
+          char_width = @char_width.call(char)
+          last_split = index if split?(char)
+          break if f(left - char_width).negative?
+
+          left = f(left - char_width)
+        end
+        index += 1
+      end
+      [index, last_split, left]
+    end
+
+    # BidiLine#getWidth
+    def width(first, last)
+      (first..last).reduce(0.0) do |sum, index|
+        NO_PRINT.match?(@chars[index]) ? sum : f(sum + @char_width.call(@chars[index]))
+      end
+    end
+
+    def last_visible(start, finish)
+      finish.downto(start).find { |index| !self.class.blank?(@chars[index]) } || (start - 1)
+    end
+
+    def split?(char) = char <= " " || char == "-" || CJK.match?(char)
+
+    def f(value) = Float32.f(value)
+  end
+end

data/lib/fillform/merged_widget.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Fillform
+  # A widget with the attributes of its field and the field's parents, like iText's merged
+  # dictionary: the widget's own entries win.
+  class MergedWidget
+    def initialize(widget, field)
+      @widget = widget
+      @field = field
+    end
+
+    def [](key) = @widget.key?(key) ? @widget[key] : @field.lookup(key)
+
+    def key?(key) = @widget.key?(key) || !@field.lookup(key).nil?
+
+    def resolve(value) = @widget.resolve(value)
+
+    def rect = @widget.rect
+  end
+end

data/lib/fillform/pdf/document.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Fillform
+  module PDF
+    # A PDF file as a store of indirect objects. Objects are read when they are first used, and
+    # writing a document writes every object reachable from the trailer, as a single revision.
+    class Document
+      Entry = Struct.new(:type, :position, :index)
+
+      attr_reader :trailer, :version
+
+      def self.open(path) = new(File.binread(path))
+
+      def initialize(data = nil)
+        @objects = {}
+        @entries = {}
+        @object_streams = {}
+        if data
+          @data = data.b
+          @version = @data[/\A%PDF-(\d\.\d)/, 1] || "1.4"
+          load_cross_references
+        else
+          @version = "1.7"
+          @trailer = {}
+        end
+      end
+
+      def deref(value)
+        value.is_a?(Reference) ? object(value.number) : value
+      end
+
+      def object(number)
+        return @objects[number] if @objects.key?(number)
+
+        @objects[number] = read_object(number)
+      end
+
+      def add(value)
+        number = [@entries.keys.max.to_i, @objects.keys.max.to_i].max + 1
+        @objects[number] = value
+        Reference.new(number, 0)
+      end
+
+      def catalog = deref(@trailer[:Root])
+
+      def pages
+        result = []
+        collect_pages(catalog[:Pages], {}, result)
+        result
+      end
+
+      def write(path)
+        File.binwrite(path, Writer.new(self, reachable).to_pdf)
+      end
+
+      # Object numbers reachable from the trailer, in ascending order.
+      def reachable
+        seen = {}
+        pending = [@trailer[:Root], @trailer[:Info]].compact
+        until pending.empty?
+          value = pending.pop
+          case value
+          when Reference
+            next if seen.key?(value.number)
+
+            seen[value.number] = true
+            pending << object(value.number)
+          when Hash then pending.concat(value.values)
+          when Array then pending.concat(value)
+          when Stream then pending.concat(value.dictionary.values)
+          end
+        end
+        seen.keys.select { |number| @objects.key?(number) && !@objects[number].nil? }.sort
+      end
+
+      private
+
+      INHERITED_PAGE_KEYS = %i[Resources MediaBox CropBox Rotate].freeze
+
+      # [reference, page dictionary, inherited attributes] in page order.
+      def collect_pages(reference, inherited, result, depth = 0)
+        node = deref(reference)
+        return unless node.is_a?(Hash) && depth < 64
+
+        if node[:Type] == :Pages || node.key?(:Kids)
+          inherited = inherited.merge(node.slice(*INHERITED_PAGE_KEYS))
+          Array(deref(node[:Kids])).each { |kid| collect_pages(kid, inherited, result, depth + 1) }
+        else
+          result << [reference, node, inherited]
+        end
+      end
+
+      def read_object(number)
+        entry = @entries[number]
+        return nil unless entry.is_a?(Entry)
+
+        entry.type == :compressed ? compressed_object(entry.position, entry.index) : object_at(number, entry.position)
+      rescue MalformedError
+        raise if @rebuilt
+
+        rebuild_cross_references
+        @objects.delete(number)
+        read_object(number)
+      end
+
+      def object_at(number, position)
+        parser = Parser.new(@data, position) { |length| deref(length) }
+        found, _generation, value = parser.parse_indirect
+        raise MalformedError, "object #{number} is not at #{position}" unless found == number
+
+        value
+      end
+
+      def compressed_object(stream_number, index)
+        offsets, data = object_stream(stream_number)
+        return nil unless offsets && index < offsets.size
+
+        Parser.new(data, offsets[index][1]).parse_object
+      end
+
+      def object_stream(number)
+        @object_streams[number] ||= begin
+          stream = object(number)
+          data = stream.data(self)
+          first = stream[:First].to_i
+          header = Parser.new(data)
+          pairs = Array.new(stream[:N].to_i) { [header.parse_object, first + header.parse_object] }
+          [pairs, data]
+        end
+      end
+
+      def load_cross_references
+        position = @data.rindex("startxref") or return rebuild_cross_references
+        position = @data[(position + 9)..][/\A\s*(\d+)/, 1].to_i
+        visited = {}
+        until position.nil? || visited.key?(position)
+          visited[position] = true
+          trailer = read_section(position)
+          @trailer ||= trailer
+          read_section(trailer[:XRefStm]) if trailer[:XRefStm].is_a?(Integer)
+          position = trailer[:Prev]
+        end
+        raise MalformedError, "no catalog" unless @trailer && @trailer[:Root]
+      rescue MalformedError, ArgumentError, NoMethodError, TypeError
+        rebuild_cross_references
+      ensure
+        raise Fillform::Error, "encrypted PDF files are not supported" if @trailer&.key?(:Encrypt)
+      end
+
+      def read_section(position)
+        parser = Parser.new(@data, position)
+        parser.skip_whitespace
+        parser.scanner.skip(/xref\b/) ? read_table(parser) : read_stream_section(parser)
+      end
+
+      def read_table(parser)
+        scanner = parser.scanner
+        while scanner.skip(/\s*(\d+)\s+(\d+)[ \t]*[\r\n]+/)
+          first = scanner[1].to_i
+          scanner[2].to_i.times do |i|
+            scanner.skip(/\s*(\d+)\s+(\d+)\s+([nf])/) or raise MalformedError, "broken cross-reference table"
+            register(first + i, Entry.new(:offset, scanner[1].to_i)) if scanner[3] == "n"
+            register(first + i, :free) if scanner[3] == "f"
+          end
+        end
+        scanner.skip(/\s*trailer/) or raise MalformedError, "no trailer"
+        parser.parse_object
+      end
+
+      def read_stream_section(parser)
+        _number, _generation, stream = parser.parse_indirect
+        raise MalformedError, "no cross-reference stream" unless stream.is_a?(Stream) && stream[:Type] == :XRef
+
+        widths = stream[:W]
+        index = stream[:Index] || [0, stream[:Size]]
+        data = stream.data(self).bytes
+        index.each_slice(2).with_object(data) do |(first, count), bytes|
+          count.times do |i|
+            fields = widths.map { |width| bytes.shift(width).reduce(0) { |sum, byte| (sum << 8) | byte } }
+            register_stream_entry(first + i, widths[0].zero? ? 1 : fields[0], fields[1], fields[2])
+          end
+        end
+        stream.dictionary
+      end
+
+      def register_stream_entry(number, type, field, index)
+        case type
+        when 0 then register(number, :free)
+        when 1 then register(number, Entry.new(:offset, field))
+        when 2 then register(number, Entry.new(:compressed, field, index))
+        end
+      end
+
+      # The newest revision is read first, so an object keeps its first entry.
+      def register(number, entry)
+        @entries[number] = entry unless @entries.key?(number)
+      end
+
+      # Finds the objects by scanning the file, like readers do with a broken cross-reference table.
+      def rebuild_cross_references
+        @rebuilt = true
+        @entries = {}
+        @objects.clear
+        @object_streams.clear
+        @data.scan(/(?<!\d)(\d+)\s+(\d+)\s+obj\b/) do
+          @entries[::Regexp.last_match(1).to_i] = Entry.new(:offset, ::Regexp.last_match.begin(0))
+        end
+        @entries.to_a.each { |number, entry| register_compressed_objects(number, entry.position) }
+        @trailer = rebuilt_trailer or raise MalformedError, "no catalog found"
+      end
+
+      # The object that comes last in the file is the newest one.
+      def register_compressed_objects(number, position)
+        stream = object(number)
+        return unless stream.is_a?(Stream) && stream[:Type] == :ObjStm
+
+        object_stream(number)[0].each_with_index do |(member, _offset), index|
+          current = @entries[member]
+          newer = current.nil? || position > file_position(current)
+          @entries[member] = Entry.new(:compressed, number, index) if newer
+        end
+      rescue MalformedError
+        nil
+      end
+
+      def file_position(entry) = entry.type == :offset ? entry.position : @entries[entry.position].position
+
+      def rebuilt_trailer
+        position = @data.rindex(/trailer\s*<</)
+        trailer = position ? Parser.new(@data, @data.index("<<", position)).parse_object : {}
+        return trailer if deref(trailer[:Root]).is_a?(Hash)
+
+        catalog = @entries.keys.find { |number| object(number).is_a?(Hash) && object(number)[:Type] == :Catalog }
+        catalog && trailer.merge(Root: Reference.new(catalog, 0))
+      rescue MalformedError
+        nil
+      end
+    end
+  end
+end

data/lib/fillform/pdf/filters.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Fillform
+  module PDF
+    # The stream filters a form template needs to be read: Flate with predictors, and the ASCII ones.
+    module Filters
+      module_function
+
+      def decode(data, filters, parameters)
+        filters = [filters].compact unless filters.is_a?(Array)
+        parameters = [parameters] unless parameters.is_a?(Array)
+        filters.each_with_index.reduce(data) do |result, (filter, index)|
+          apply(filter, result, parameters[index].is_a?(Hash) ? parameters[index] : {})
+        end
+      end
+
+      def apply(filter, data, parameters)
+        case filter
+        when :FlateDecode, :Fl then predict(inflate(data), parameters)
+        when :ASCIIHexDecode, :AHx then hex(data)
+        when :ASCII85Decode, :A85 then ascii85(data)
+        else raise MalformedError, "unsupported stream filter #{filter}"
+        end
+      end
+
+      # Tolerates truncated and trailing bytes like PDF readers do.
+      def inflate(data)
+        inflater = Zlib::Inflate.new
+        result = +""
+        begin
+          result << inflater.inflate(data)
+        rescue Zlib::BufError, Zlib::DataError
+          nil
+        end
+        result.b
+      ensure
+        inflater&.close
+      end
+
+      def predict(data, parameters)
+        predictor = parameters[:Predictor].to_i
+        return data if predictor < 2
+
+        colors = (parameters[:Colors] || 1).to_i
+        bits = (parameters[:BitsPerComponent] || 8).to_i
+        columns = (parameters[:Columns] || 1).to_i
+        pixel = [(colors * bits / 8.0).ceil, 1].max
+        row = (columns * colors * bits / 8.0).ceil
+        predictor == 2 ? tiff(data, row, pixel) : png(data, row, pixel)
+      end
+
+      def png(data, row, pixel)
+        previous = Array.new(row, 0)
+        result = []
+        data.bytes.each_slice(row + 1) do |type, *line|
+          line.fill(0, line.size...row)
+          line.each_index do |i|
+            left = i >= pixel ? line[i - pixel] : 0
+            above = previous[i]
+            above_left = i >= pixel ? previous[i - pixel] : 0
+            line[i] = (line[i] + png_predictor(type, left, above, above_left)) & 0xFF
+          end
+          result.concat(line)
+          previous = line
+        end
+        result.pack("C*")
+      end
+
+      def png_predictor(type, left, above, above_left)
+        case type
+        when 1 then left
+        when 2 then above
+        when 3 then (left + above) / 2
+        when 4 then paeth(left, above, above_left)
+        else 0
+        end
+      end
+
+      def paeth(left, above, above_left)
+        estimate = left + above - above_left
+        distances = [left, above, above_left].map { |value| (estimate - value).abs }
+        return left if distances[0] <= distances[1] && distances[0] <= distances[2]
+
+        distances[1] <= distances[2] ? above : above_left
+      end
+
+      def tiff(data, row, pixel)
+        data.bytes.each_slice(row).flat_map do |line|
+          line.each_index { |i| line[i] = (line[i] + line[i - pixel]) & 0xFF if i >= pixel }
+          line
+        end.pack("C*")
+      end
+
+      def hex(data)
+        digits = data.delete("^0-9A-Fa-f>").split(">").first.to_s
+        [digits.length.odd? ? "#{digits}0" : digits].pack("H*")
+      end
+
+      def ascii85(data)
+        text = data.delete(" \t\r\n\f\0").delete_prefix("<~").split("~>").first.to_s.gsub("z", "!!!!!")
+        text.scan(/.{1,5}/).map do |group|
+          value = group.ljust(5, "u").bytes.reduce(0) { |sum, byte| (sum * 85) + byte - 33 }
+          [value].pack("N")[0, group.length - 1]
+        end.join.b
+      end
+    end
+  end
+end

data/lib/fillform/pdf/objects.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Fillform
+  module PDF
+    class MalformedError < Fillform::Error; end
+
+    # Dictionaries are Hashes with Symbol keys, names are Symbols, strings are binary Strings.
+    Reference = Struct.new(:number, :generation) do
+      def to_s = "#{number} #{generation} R"
+      alias_method :inspect, :to_s
+    end
+
+    class Stream
+      attr_accessor :dictionary, :raw
+
+      # A new stream is compressed, a stream read from a file keeps its encoded bytes.
+      def self.compressed(dictionary, data)
+        new(dictionary.merge(Filter: :FlateDecode), Zlib::Deflate.deflate(data))
+      end
+
+      def initialize(dictionary, raw)
+        @dictionary = dictionary
+        @raw = raw
+      end
+
+      def [](key) = @dictionary[key]
+
+      def []=(key, value)
+        @dictionary[key] = value
+      end
+
+      def key?(key) = @dictionary.key?(key)
+
+      def data(document = nil)
+        Filters.decode(@raw, resolve(document, @dictionary[:Filter]), resolve(document, @dictionary[:DecodeParms]))
+      end
+
+      private
+
+      def resolve(document, value)
+        value = document.deref(value) if document
+        value.is_a?(Array) && document ? value.map { |item| document.deref(item) } : value
+      end
+    end
+  end
+end